first commit

This commit is contained in:
dahyeon committed 2025-11-13 15:46:15 +00:00
commit 9d65fbd235
57 files changed
+15094

No files matched your search

@@ -0,0 +1,4 @@
// auth/public.decorator.ts
import { SetMetadata } from '@nestjs/common';
export const METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED = 'IS_PUBLIC_ACCESS_ALLOWED';
export const AllowPublicAccess = () => SetMetadata(METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, true);
+8
View File
@@ -0,0 +1,8 @@
import { Module } from "@nestjs/common";
import { JwtService } from "./jwt.service";
@Module({
providers: [JwtService],
exports: [JwtService],
})
export class AuthModule {}
@@ -0,0 +1,17 @@
import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { EntraIDPayloadClaims, JwtService } from './jwt.service';
import { Request } from 'express';
import {
decodeJwt
} from 'jose';
//request에서 user 정보만
export const ExtractUserPayloadFromToken = createParamDecorator(async (data: unknown, ctx: ExecutionContext) => {
const request: Request = ctx.switchToHttp().getRequest();
const token = request.header('authorization')?.replace('Bearer ', '');
const claims = decodeJwt(token!) as EntraIDPayloadClaims
// 요청 메타데이터 저장
const { aud, iss, iat, nbf, rh, ver, ...accountMetadata } = claims
// global.__drizzleContexts = accountMetadata;
return accountMetadata;
});
+96
View File
@@ -0,0 +1,96 @@
// src/auth/jwt.guard.ts
import {
CanActivate,
ExecutionContext,
Injectable,
UnauthorizedException,
ForbiddenException,
} from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { IdentityProviderName, JwtService } from './jwt.service';
import { decodeJwt } from 'jose';
import { METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED } from './allow-public-access.decorator';
@Injectable()
export class JwtAuthGuard implements CanActivate {
constructor(
private readonly reflector: Reflector,
private readonly jwtService: JwtService,
) {}
async canActivate(context: ExecutionContext): Promise<boolean> {
const isPublicAccessAllowed = this.reflector.getAllAndOverride<boolean>(METADATA_KEY_IS_PUBLIC_ACCESS_ALLOWED, [
context.getHandler(),
context.getClass(),
]);
if (isPublicAccessAllowed) return true;
const request = context.switchToHttp().getRequest();
const authz = request.headers?.authorization as string | undefined;
if (!authz || !authz.startsWith('Bearer ')) {
throw new UnauthorizedException('Missing or invalid Authorization header');
}
const token = authz.slice('Bearer '.length).trim();
if (!token) {
throw new UnauthorizedException('Empty bearer token');
}
// let identityProvider =
// this.reflector.getAllAndOverride<IdentityProviderName>(IDP_KEY, [
// context.getHandler(),
// context.getClass(),
// ]);
// if (!identityProvider) {
// }
let identityProvider: IdentityProviderName;
try {
const { iss } = decodeJwt(token) as { iss?: string };
if (!iss) {
throw new UnauthorizedException('Token has no issuer (iss) claim');
}
identityProvider = this.pickIdPFromIssuer(iss);
} catch (e) {
throw new UnauthorizedException(
e instanceof Error ? e.message : 'Unable to decode token',
);
}
try {
const verifyResult = await this.jwtService.verify(token, identityProvider);
request.user = verifyResult.payload;
request.tokenHeader = verifyResult.protectedHeader;
request.identityProvider = identityProvider;
return true;
} catch (e) {
const msg = e instanceof Error ? e.message : 'JWT verification failed';
// iss/aud 불일치는 보통 401, 접근권한 이슈는 403 (여기선 401로 통일)
throw new UnauthorizedException(msg);
}
}
/**
* issuer(iss)로부터 IdP 추정
* - Entra ID: https://login.microsoftonline.com/<tenant>/v2.0
* - Cognito: https://cognito-idp.<region>.amazonaws.com/<userPoolId>
*/
private pickIdPFromIssuer(issuer: string): IdentityProviderName {
const lower = issuer.toLowerCase();
if (lower.includes('login.microsoftonline.com')) {
return 'MICROSOFT_ENTRAID';
}
if (lower.includes('cognito-idp.') && lower.includes('.amazonaws.com')) {
return 'AMAZON_COGNITO';
}
// 필요하다면 여기서 jwtService 내부에 등록된 issuer들로 엄격 매칭하도록 변경 가능:
// const configuredIssuers = this.jwtService.getConfiguredIssuers?.();
// ...
throw new ForbiddenException(`Unknown issuer: ${issuer}`);
}
}
+202
View File
@@ -0,0 +1,202 @@
// src/auth/azure-jwt.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common';
import { SecretService } from '../secret/secret.service';
import {
createRemoteJWKSet,
jwtVerify,
JWTPayload,
JWTVerifyResult,
} from 'jose';
/**
* Microsoft Entra ID 를 IdP로 사용하는 OpenID Connect 인증 관련 모듈.
* OIDC 인증 흐름 -> https://learn.microsoft.com/ko-kr/entra/architecture/auth-oidc 문서 참조.
* 추후 IdP 확장 고려해 IdP 별로 해당 IdP 이름을 접두사에 붙인다.
*/
export type IdentityProviderName = 'MICROSOFT_ENTRAID' | 'AMAZON_COGNITO';
// export type IdentityProvider = {
// [x in IdentityProviderName]: EntraIDIdentityProviderMetadata
// };
// export type EntraIDIdentityProviderMetadata = {
// issuer: string;
// authorizationEndpoint: string;
// tokenEndpoint: string;
// userInfoEndpoint: string;
// jwksUri: string;
// }
/**
* https://learn.microsoft.com/en-us/entra/identity-platform/access-token-claims-reference
* Microsoft Entra access-token의 페이로드 클레임. (v2.0)
* {
aud: 'd182d8e3-fa47-4b93-a736-8c4b7c25bc97',
iss: 'https://login.microsoftonline.com/5ef88004-e953-4b04-93db-64bbf49c6863/v2.0',
iat: 1762581073,
nbf: 1762581073,
exp: 1762584973,
idp: 'https://sts.windows.net/9188040d-6c67-4c5b-b112-36a304b66dad/',
name: '박 다현',
nonce: '019a6209-2ad0-7ff3-b602-717dc84110c7',
oid: 'f0e47b9f-00cd-4dcc-b324-982c87925be3',
preferred_username: 'park@dahyeon.us',
prov_data: [ [Object] ],
rh: '1.ASsABID4XlPpBEuT22S79JxoY-PYgtFH-pNLpzaMS3wlvJfCAPErAA.',
sid: '00a91929-edb8-af0a-4867-1a286d232132',
sub: 'wOWxMykMnhSt4ze00IBprHGCXR17VGmpB384UmoJb4I',
tid: '5ef88004-e953-4b04-93db-64bbf49c6863',
uti: 'Zum6q_BVMkmKGtgKL21UAA',
ver: '2.0'
},
*/
export type EntraIDPayloadClaims = {
aud: string;
iss: string;
iat: number;
lap: string;
nbf: number;
exp: number;
name: string;
nonce: string;
oid: string;
preferred_username: string;
prov_data: [{}],
rh: string;
sid: string;
sub: string;
tid: string;
uti: string;
ver: '2.0';
}
@Injectable()
export class JwtService implements OnModuleInit {
private jwtClaimAudience: string;
private MICROSOFT_ENTRAID_tenantId: string;
private MICROSOFT_ENTRAID_allowedAlgs: string;
private MICROSOFT_ENTRAID_issuer: string;
private MICROSOFT_ENTRAID_jwksUri: string;
private MICROSOFT_ENTRAID_jwks: () => Promise<CryptoKey>;
private readonly tokenSigningAlgValuesSupported = ['RS256'];
private readonly clockTolerance =
Number(process.env.JWT_CLOCK_TOLERANCE || 5); // seconds
constructor(
private readonly secretService: SecretService
) {}
public async onModuleInit() {
await this.secretService.ready()
this.jwtClaimAudience = await this.secretService.get('JWT_CLAIM_AUDIENCE')
this.MICROSOFT_ENTRAID_tenantId = await this.secretService.get('MICROSOFT_ENTRAID_TENANT_ID')
this.MICROSOFT_ENTRAID_allowedAlgs = await this.secretService.get('MICROSOFT_ENTRAID_ALLOWED_ALGS')
this.MICROSOFT_ENTRAID_issuer = `https://login.microsoftonline.com/${this.MICROSOFT_ENTRAID_tenantId}/v2.0`;
this.MICROSOFT_ENTRAID_jwksUri = `https://login.microsoftonline.com/common/discovery/v2.0/keys`;
const remoteJWKSet = createRemoteJWKSet(new URL(this.MICROSOFT_ENTRAID_jwksUri), {
// cache: true,
cooldownDuration: 30_000,
timeoutDuration: 10_000,
})
this.MICROSOFT_ENTRAID_jwks = remoteJWKSet;
try {
await remoteJWKSet.reload();
} catch (e) {
// 초기 로드 실패는 무시하거나 로깅
console.warn('Failed to preload Entra JWKs:', e);
}
console.log(remoteJWKSet.jwks(), 'Entra JWKs loaded');
}
/**
* Authorization: Bearer <token> 의 <token> 부분을 검증.
* - iss: IdP 별 설정에 따라.
* - aud: Application ID URI와 정확히 일치해야 함
* - alg: IdP 마다 허용된 설정에 따라야 함
*/
async verify(
token: string,
identityProvider: IdentityProviderName
): Promise<JWTVerifyResult<JWTPayload>> {
console.log('Verifying JWT token');
if (!token) {
throw new Error('Empty token');
}
// IdP별 설정 매핑
const providers: {
[x in IdentityProviderName]: {
jwks: () => Promise<CryptoKey>;
issuer: string;
audience: string;
extraValidate?: (payload: JWTPayload) => void;
};
} = {
MICROSOFT_ENTRAID: {
jwks: this.MICROSOFT_ENTRAID_jwks,
issuer: this.MICROSOFT_ENTRAID_issuer,
audience: this.jwtClaimAudience,
extraValidate: (payload: JWTPayload) => {
// AAD v2 토큰 전용 추가 검증
if (payload['ver'] && payload['ver'] !== '2.0') {
throw new Error(`Unsupported AAD token version: ${payload['ver']}`);
}
if (payload['tid'] && payload['tid'] !== this.MICROSOFT_ENTRAID_tenantId) {
throw new Error(`Unexpected tenant: ${payload['tid']}`);
}
},
},
AMAZON_COGNITO: {
// TODO : Cognito 통합.. 언젠가...
jwks: this['AMAZON_COGNITO_jwks'],
issuer: this['AMAZON_COGNITO_issuer'],
audience: this['AMAZON_COGNITO_audience'],
extraValidate: (payload: JWTPayload) => {
},
},
} as const;
const provider = providers[identityProvider];
console.log('Using identity provider:', provider.jwks);
if (!provider?.jwks || !provider?.issuer || !provider?.audience) {
throw new Error(`Identity provider not configured: ${identityProvider}`);
}
const allowedAlgs =
(this.MICROSOFT_ENTRAID_allowedAlgs
? this.MICROSOFT_ENTRAID_allowedAlgs.split(',').map(s => s.trim()).filter(Boolean)
: this.tokenSigningAlgValuesSupported) as string[];
let result
try {
result = await jwtVerify(token, provider.jwks, {
issuer: provider.issuer,
audience: provider.audience,
algorithms: allowedAlgs,
clockTolerance: this.clockTolerance,
});
console.log(result, 'jwt verify result');
} catch (e) {
// const msg = e instanceof Error ? e.message : 'JWT verification error';
// throw new Error(`JWT verification failed: ${msg}`);
console.log('JWT verification failed:', e);
throw e;
}
const { payload, protectedHeader } = result;
if (!allowedAlgs.includes(protectedHeader.alg as string)) {
throw new Error(`Unexpected alg: ${protectedHeader.alg}`);
}
provider.extraValidate?.(payload);
return result;
}
}
@@ -0,0 +1,94 @@
import { Injectable, Scope, OnModuleInit } from '@nestjs/common';
import mongoose from 'mongoose';
import { SecretService } from '../secret/secret.service.js';
import { moeumModelDefinitions, MoeumModelTypes } from './schema.js';
@Injectable({ scope: Scope.DEFAULT })
export class ConnectionService implements OnModuleInit {
private connection: mongoose.Connection | null = null;
constructor(private readonly secretService: SecretService) {}
private moeumModels: Map<string, mongoose.Model<any>> | null = null;
public async getConnection(): Promise<mongoose.Connection> {
if (this.connection !== null && this.connection.readyState === 1) {
return this.connection;
}
const connectionString = await this.secretService.get(
'MONGODB_CONNECTION_STRING',
);
const defaultConnection = await mongoose
.createConnection(connectionString, {
dbName: 'moeum',
minPoolSize: 10,
maxPoolSize: 20,
})
.asPromise();
this.connection = defaultConnection;
console.log('Default Connection이 새로 생성됨.');
return this.connection;
}
public async getMoeumModels<K extends keyof MoeumModelTypes>(
modelKey: K,
): Promise<mongoose.Model<MoeumModelTypes[K]>> {
if (this.moeumModels)
return this.moeumModels.get(modelKey) as mongoose.Model<
MoeumModelTypes[K]
>;
const moeumModels = new Map<K, mongoose.Model<MoeumModelTypes[K]>>();
// const connection = await this.getTenantConnection(tenantId);
const connection = await this.getConnection();
moeumModelDefinitions.forEach((modelDefinition) => {
// 이미 생성된 경우 컴파일 스킵.
if (
Object.prototype.hasOwnProperty.call(
connection.models,
modelDefinition.name,
)
) {
moeumModels.set(
modelDefinition.name as K,
connection.models[modelDefinition.name],
);
return;
} else {
moeumModels.set(
modelDefinition.name as K,
connection.model(
modelDefinition.name,
modelDefinition.schema,
modelDefinition.schemaName,
),
);
}
});
this.moeumModels = moeumModels;
return moeumModels.get(modelKey) as mongoose.Model<MoeumModelTypes[K]>;
}
public async createSession(
options?: mongoose.ClientSessionOptions,
): Promise<mongoose.ClientSession | undefined> {
try {
const connection = await this.getConnection();
const session = await connection.startSession(options);
return session as unknown as mongoose.ClientSession;
} catch (error) {
console.log(error);
}
}
public async onModuleInit() {
await this.getConnection().catch(console.error);
}
public async onModuleDestroy() {
this.connection?.close();
}
}
@@ -0,0 +1,9 @@
import { DynamicModule, Module } from '@nestjs/common';
import { ConnectionService } from './connection.service.js';
@Module({
imports: [],
providers: [ConnectionService],
exports: [ConnectionService],
})
export class DatabaseModule {}
+182
View File
@@ -0,0 +1,182 @@
import mongoose, { Schema, Document } from 'mongoose';
import { ModelDefinition } from './types';
export interface Metadata {
key: string;
value: string | any[] | null;
dataType: string;
isReserved: boolean;
}
export interface TaxonomyChildItem {
title: string;
order: number;
articleId?: mongoose.Types.ObjectId;
slug?: string; //article document의 slug 참조 (임베딩)
children?: TaxonomyChildItem[];
}
export interface Taxonomy extends Document {
label: string;
items: TaxonomyChildItem[];
metadatas: Metadata[];
}
export interface ContentSection {
heading: string;
taxonomies: mongoose.Types.ObjectId[];
}
export interface Content extends Document {
key: string;
label: string;
sections: ContentSection[];
}
export interface Article extends Document {
title: string;
slug: string;
content: string;
status: 'draft' | 'published' | 'archived';
metadatas: Metadata[];
}
export const MetadataSubSchema = new mongoose.Schema<Metadata>({
key: { type: String, required: true },
value: {
type: mongoose.SchemaTypes.Mixed,
required: false, // required: true로 하면 value가 null인 경우 에러 발생
default: null,
validate: {
validator: function (v: string | any[] | null) {
// 특정 키인 경우 value가 null 또는 빈 문자열이 아니어야 함
// if (this.key === 'requiredKey') {
// return typeof v === 'string' && v.trim().length > 0;
// }
// 그렇지 않은 경우 value는 null 또는 문자열, Array이어야 함
return v === null || typeof v === 'string' || Array.isArray(v);
},
message: function (props: any) {
if (this.key === 'requiredKey') {
return `Value is required for key "${this.key}" and cannot be null or empty.`;
}
return `Value must be a string, an array, or null for key "${this.key}".`;
},
},
},
dataType: { type: String, required: false, default: 'string' },
isReserved: { type: Boolean, required: false, default: false },
});
export const TaxonomyChildItemSchema = new Schema(
{
title: { type: String, required: true },
order: { type: Number, required: true, default: 100 },
slug: { type: String }, // slug는 없을 수도 있으므로 required 제외
articleId: { type: Schema.Types.ObjectId, ref: 'article' },
},
{
_id: false, // 하위 아이템마다 _id가 생성되는 것을 방지 (선택 사항)
},
);
// **중요: 재귀 참조 설정**
// 스키마 정의 후 .add()를 통해 자기 자신을 children 배열로 추가합니다.
TaxonomyChildItemSchema.add({
children: { type: [TaxonomyChildItemSchema], default: [] },
});
// 2. 메인 도큐먼트 스키마 (Root)
export const TaxonomySchema = new Schema(
{
// items 배열은 위에서 정의한 재귀 스키마를 따름
label: { type: String, required: true },
items: {
type: [TaxonomyChildItemSchema],
default: [],
},
// metadata는 구조가 가변적이므로 Mixed 타입 사용
metadatas: {
type: [MetadataSubSchema],
required: true,
default: [],
validate: {
validator: function (metas: Metadata[]) {
const keys = metas.map((m) => m.key);
return keys.length === new Set(keys).size;
},
message: 'Duplicate metadata keys are not allowed.',
},
},
},
{
timestamps: true, // createAt, updatedAt 자동 생성
collection: 'taxonomy', // 컬렉션 이름 지정
},
);
TaxonomySchema.index({ label: 1 }, { unique: true });
export const ContentSchema = new Schema(
{
key: { type: String, required: true, unique: true },
label: { type: String, required: true },
sections: {
type: [
{
heading: { type: String, required: true },
taxonomies: [{ type: Schema.Types.ObjectId, ref: 'taxonomy' }],
},
],
default: [],
},
},
{
timestamps: true,
collection: 'content',
},
);
export const ArticleSchema = new Schema(
{
title: { type: String, required: true },
content: { type: String, required: true },
slug: { type: String, required: true, unique: true },
status: {
type: String,
enum: ['draft', 'published', 'archived'],
default: 'draft',
},
metadatas: {
type: [MetadataSubSchema],
required: true,
default: [],
validate: {
validator: function (metas: Metadata[]) {
const keys = metas.map((m) => m.key);
return keys.length === new Set(keys).size;
},
message: 'Duplicate metadata keys are not allowed.',
},
},
},
{
timestamps: true,
collection: 'article',
},
);
ArticleSchema.index({ title: 'text', content: 'text' });
export const moeumModelDefinitions: ModelDefinition[] = [
{ name: 'taxonomy', schema: TaxonomySchema, schemaName: 'taxonomy' },
{ name: 'content', schema: ContentSchema, schemaName: 'content' },
{ name: 'article', schema: ArticleSchema, schemaName: 'article' },
];
export interface MoeumModelTypes {
taxonomy: Taxonomy;
content: Content;
article: Article;
}
+5
View File
@@ -0,0 +1,5 @@
export interface ModelDefinition {
name: string;
schema: mongoose.Schema<any>;
schemaName?: string;
}
+31
View File
@@ -0,0 +1,31 @@
import { Module, Global } from '@nestjs/common';
import { SecretModule } from './secret/secret.module';
// import { DatabaseModule } from './database/database.module';
import { NatsModule } from './nats/nats.module';
import { JwtService } from './auth/jwt.service';
import { MinioModule } from './minio/minio.module';
import { AuthModule } from './auth/auth.module';
import { DatabaseModule } from './database/database.module';
// import { DatabaseModule } from './database/database.module';
@Global()
@Module({
imports: [
SecretModule,
NatsModule,
MinioModule,
AuthModule,
MinioModule,
DatabaseModule,
],
providers: [JwtService],
exports: [
SecretModule,
NatsModule,
MinioModule,
AuthModule,
MinioModule,
DatabaseModule,
],
})
export class GlobalModule {}
+8
View File
@@ -0,0 +1,8 @@
import { Module } from "@nestjs/common";
import { MinioService } from "./minio.service";
@Module({
providers: [MinioService],
exports: [MinioService],
})
export class MinioModule {}
+60
View File
@@ -0,0 +1,60 @@
import { Injectable, OnModuleInit } from "@nestjs/common";
import { SecretService } from "../secret/secret.service";
import * as Minio from 'minio'
import { Temporal } from "temporal-polyfill";
@Injectable()
export class MinioService implements OnModuleInit {
private minioClient: Minio.Client;
private endpoint: string;
private accessKey: string;
private secretKey: string;
private readonly bucketName = 'wiki-image'
constructor(
private readonly secretService: SecretService
) {}
public async onModuleInit() {
await this.secretService.ready()
this.endpoint = await this.secretService.get('MINIO_ENDPOINT')
this.accessKey = await this.secretService.get('MINIO_ACCESS_KEY')
this.secretKey = await this.secretService.get('MINIO_SECRET_KEY')
this.minioClient = new Minio.Client({
endPoint: this.endpoint,
useSSL: true,
accessKey: this.accessKey,
secretKey: this.secretKey,
})
}
// uploadFile(file: Buffer): Promise<string>
// uploadFile(file: Express.Multer.File): Promise<string>
public async uploadFile(file: Express.Multer.File): Promise<string> {
const date = Temporal.Now.plainDateISO().toString()
const s3ObjectKey = `${date}/${file.originalname}`
const metaData = {
'Content-Type': file.mimetype,
'X-Amz-Meta-serviceName': 'wiki',
}
const fileBuffer = Buffer.from(file.buffer)
await this.minioClient.putObject(this.bucketName, s3ObjectKey, fileBuffer, file.size, metaData)
return s3ObjectKey
}
public async uploadImage(file: Express.Multer.File): Promise<string> {
const date = Temporal.Now.plainDateISO().toString()
const s3ObjectKey = `${date}/${file.originalname.split('.')[0]}/original.${file.originalname.split('.').pop()}`
console.log(s3ObjectKey)
const metaData = {
'Content-Type': file.mimetype,
'X-Amz-Meta-serviceName': 'wiki',
}
const fileBuffer = Buffer.from(file.buffer)
await this.minioClient.putObject(this.bucketName, s3ObjectKey, fileBuffer, file.size, metaData)
return s3ObjectKey
}
}
+8
View File
@@ -0,0 +1,8 @@
import { Module } from "@nestjs/common";
import { NatsService } from "./nats.service";
@Module({
providers: [NatsService],
exports: [NatsService],
})
export class NatsModule {}
+64
View File
@@ -0,0 +1,64 @@
import { Injectable, OnModuleDestroy, OnModuleInit } from "@nestjs/common";
import { NatsConnection, StringCodec, connect } from "nats";
import { SecretService } from "../secret/secret.service";
import fs from "fs/promises";
@Injectable()
export class NatsService implements OnModuleInit, OnModuleDestroy {
private natsClient: NatsConnection;
private endpoint: string;
private user: string;
private password: string;
private readonly stringCodec = StringCodec();
constructor(
private readonly secretService: SecretService
) {}
async onModuleInit() {
await this.secretService.ready();
this.endpoint = await this.secretService.get("NATS_ENDPOINT");
this.user = await this.secretService.get("NATS_USER");
this.password = await this.secretService.get("NATS_PASS");
// console.log(this.endpoint)
const cacert = (await fs.readFile("internal-service-ca.pem")).toString()
this.natsClient = await connect({
name : "wiki-server",
servers: [this.endpoint],
tls: {
ca: cacert,
},
maxReconnectAttempts: -1,
reconnectTimeWait: 500,
reconnect: true,
pingInterval: 20000,
timeout: 5000,
user: this.user,
pass: this.password
});
// const result = await this.natsClient.status();
// console.log(result)
}
async onModuleDestroy() {
if (!this.natsClient) return;
try {
// 안전 종료: drain -> closed 대기
const closed = this.natsClient.closed();
await this.natsClient.drain();
const err = await closed;
if (err) console.error("NATS closed with error:", err);
} catch (e) {
// drain 실패 시 강제 close
try { await this.natsClient.close(); } catch {}
}
}
public async publish<T = unknown>(subject: string, data: T): Promise<void> {
this.natsClient.publish(subject, this.stringCodec.encode(JSON.stringify(data)));
await this.natsClient.flush();
}
}
@@ -0,0 +1,10 @@
import { Module } from "@nestjs/common";
import { SecretService } from "./secret.service";
@Module({
imports: [],
providers: [SecretService],
exports: [SecretService],
})
export class SecretModule {}
+134
View File
@@ -0,0 +1,134 @@
import { Injectable, Logger } from '@nestjs/common';
import { InfisicalSDK } from '@infisical/sdk';
import { ConfigService } from '@nestjs/config';
type SecretMap = Record<string, string | boolean | undefined>;
@Injectable()
export class SecretService {
private logger = new Logger(SecretService.name);
private secrets: SecretMap | null = null; // null = 아직 로드 전
private loading?: Promise<void>; // 진행 중인 로드(중복 호출 방지)
private infisicalClient: InfisicalSDK;
private readonly siteUrl: string;
private readonly clientSecret: string;
private readonly clientId: string;
private readonly projectId: string;
private readonly PROCESS_ENVS = [
'COSMOSDB_ENDPOINT',
'COSMOSDB_KEY',
'NATS_ENDPOINT',
'NATS_TOKEN',
'NATS_URL',
// 필요시 추가
] as const;
constructor(private readonly config: ConfigService) {
this.siteUrl =
this.config.get<string>('INFISICAL_SITE_URL') ??
'https://secret-manager.dahyeon.us/';
this.clientSecret = this.config.get<string>(
'INFISICAL_CLIENT_SECRET',
) as string;
this.clientId = this.config.get<string>('INFISICAL_CLIENT_ID') as string;
this.projectId = this.config.get<string>('INFISICAL_PROJECT_ID') as string;
// console.log(this.siteUrl, this.clientSecret, this.clientId, this.projectId)
if (!this.siteUrl || !this.clientSecret || !this.clientId) {
throw new Error('Missing required Infisical configuration');
}
this.infisicalClient = new InfisicalSDK({ siteUrl: this.siteUrl });
}
/** 한 번만 로그인/페치. 동시에 여러 번 호출돼도 같은 Promise를 공유 */
private async fetchSecrets(): Promise<void> {
if (this.secrets) return; // 이미 로드됨
if (this.loading) return this.loading; // 로드 중이면 그거 기다리기
this.loading = (async () => {
await this.infisicalClient.auth().universalAuth.login({
clientId: this.clientId,
clientSecret: this.clientSecret,
});
// console.log(this.infisicalClient)
const res = await this.infisicalClient.secrets().listSecrets({
environment:
process.env.NODE_ENV === 'prod'
? 'prod'
: process.env.NODE_ENV === 'test'
? 'staging'
: 'dev',
projectId: this.projectId,
});
// 임시 객체에 채운 뒤 한 번에 교체(일관성 보장)
const map: SecretMap = {};
for (const s of res.secrets) {
map[s.secretKey] = s.secretValue;
}
// 필요한 값은 process.env에 반영
for (const k of this.PROCESS_ENVS) {
const v = map[k as string];
if (typeof v === 'string' && v.length > 0) {
process.env[k as string] = v;
}
}
this.secrets = map;
this.logger.log(
`Fetched ${Object.keys(map).length} secrets from Infisical`,
);
})();
try {
await this.loading;
} finally {
this.loading = undefined; // 실패/성공 모두 끝나면 해제(실패 시 재시도 가능)
}
}
/** lazy get: 필요할 때 처음 한번만 로드 */
public async get<T = string>(key: string, fallback?: T): Promise<T> {
if (!this.secrets) {
await this.fetchSecrets();
}
// console.log('Secrets loaded:', this.secrets);
const val = this.secrets![key];
if (val === undefined) {
const cfg = this.config.get<T>(key);
if (cfg !== undefined) return cfg;
if (fallback !== undefined) return fallback;
throw new Error(`Secret not found for key="${key}"`);
}
return val as T;
}
/** 필요 시: 동기 접근(초기화 안됐으면 에러). constructor 등에서 강제 사용 금지 */
public getSync<T = string>(key: string, fallback?: T): T {
if (!this.secrets) {
const cfg = this.config.get<T>(key);
if (cfg !== undefined) return cfg;
if (fallback !== undefined) return fallback;
throw new Error(`SecretService not initialized yet (key="${key}")`);
}
const val = this.secrets[key];
if (val === undefined) {
const cfg = this.config.get<T>(key);
if (cfg !== undefined) return cfg;
if (fallback !== undefined) return fallback;
throw new Error(`Secret not found for key="${key}"`);
}
return val as T;
}
/** 선택: 사전에 강제로 로드하고 싶을 때 호출 */
public async ready(): Promise<void> {
await this.fetchSecrets();
}
}