@alloy-framework/core 0.4.0 → 0.14.0

package/src/data/AlloyMongoModel.js

@@ -1,265 +0,0 @@
-import native from '@alloy-framework/rust';
-import { AlloyModel } from './AlloyModel.js';
-import { validateForSave, validateForUpdate, applyMongoDefaults } from './validationHelper.js';
-import { AlloyError } from '../util/AlloyError.js';
-
-/**
- * 🍃 Alloy MongoDB 전용 모델
- * MongoDB의 find, insertOne, updateOne, aggregate 등 직관적 API를 제공합니다.
- * 내부적으로 Rust의 mongoCommand (run_command)를 래핑합니다.
- *
- * @example
- * class ActivityLogs extends AlloyMongoModel {
- *     constructor() { super('activity_logs'); }
- * }
- *
- * const logs = await new ActivityLogs().find({ domain: 'AUTH' }, { sort: { _id: -1 }, limit: 50 });
- */
-export class AlloyMongoModel extends AlloyModel {
-    /**
-     * @param {string} collection - MongoDB 컬렉션 이름
-     * @param {string} [store='mongo_main'] - alloy.conf에 정의된 MongoDB 스토어 이름
-     */
-    constructor(collection, store = 'mongo_main') {
-        super(collection, store); // AlloyModel 생성자: table, store, _native 초기화
-        /** @type {string} 컬렉션 이름 (MongoDB 전용 별칭) */
-        this.collection = collection;
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📖 조회 (Read)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 문서 배열 조회
-     * @param {object} [filter={}] - 검색 조건
-     * @param {object} [options={}] - 조회 옵션 (sort, limit, skip, projection)
-     * @returns {Promise<object[]>} 문서 배열
-     */
-    async find(filter = {}, options = {}) {
-        const cmd = { find: this.collection, filter };
-        if (options.sort) cmd.sort = options.sort;
-        if (options.limit != null) cmd.limit = options.limit;
-        if (options.skip != null) cmd.skip = options.skip;
-        if (options.projection) cmd.projection = options.projection;
-
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        return result?.cursor?.firstBatch || [];
-    }
-
-    /**
-     * 단일 문서 조회
-     * @param {object} [filter={}] - 검색 조건
-     * @param {object} [options={}] - 조회 옵션
-     * @returns {Promise<object|null>} 문서 또는 null
-     */
-    async findOne(filter = {}, options = {}) {
-        const docs = await this.find(filter, { ...options, limit: 1 });
-        return docs[0] || null;
-    }
-
-    /**
-     * 문서 수 조회
-     * - filter 인자가 있으면 mongoCommand 직접 실행
-     * - filter 없이 체이닝(.where().count()) 시 부모 AlloyModel.count() 위임
-     * @param {object} [filter] - 검색 조건 (없으면 체이닝 조건 사용)
-     * @returns {Promise<number>}
-     */
-    async count(filter) {
-        // 명시적 filter가 있으면 mongoCommand 직접 실행
-        if (filter && Object.keys(filter).length > 0) {
-            const result = await this._native.mongoCommand(
-                JSON.stringify({ count: this.collection, query: filter }),
-            );
-            return result?.n || 0;
-        }
-        // 체이닝 where 조건 사용 → 부모 AlloyModel.count() (aggregate $sum:1)
-        return super.count();
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // ✏️ 삽입 (Create)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 단일 문서 삽입
-     * @param {object} doc - 삽입할 문서
-     * @returns {Promise<object>} { ok, n }
-     */
-    async insertOne(doc) {
-        const schema = this.constructor.schema;
-        doc = await validateForSave(schema, doc);
-        applyMongoDefaults(schema, doc);
-
-        const cmd = { insert: this.collection, documents: [doc], ordered: true };
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        this._assertOk(result, 'insertOne');
-        return { ok: true, n: result?.n || 1 };
-    }
-
-    /**
-     * 다중 문서 삽입
-     * @param {object[]} docs - 삽입할 문서 배열
-     * @param {object} [options={}] - 옵션 { ordered: true }
-     * @returns {Promise<object>} { ok, n }
-     */
-    async insertMany(docs, options = {}) {
-        const schema = this.constructor.schema;
-
-        // 각 문서에 GooseValidator 검증 + 기본값 주입
-        for (const doc of docs) {
-            await validateForSave(schema, doc);
-            applyMongoDefaults(schema, doc);
-        }
-
-        const cmd = {
-            insert: this.collection,
-            documents: docs,
-            ordered: options.ordered !== false,
-        };
-
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        this._assertOk(result, 'insertMany');
-        return { ok: true, n: result?.n || docs.length };
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔄 수정 (Update)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 단일 문서 수정
-     * @param {object} filter - 검색 조건
-     * @param {object} update - 수정 내용 (예: { $set: { name: 'new' } })
-     * @param {object} [options={}] - 옵션 { upsert, arrayFilters, hint, collation }
-     * @returns {Promise<object>} { ok, nModified, upserted }
-     */
-    async updateOne(filter, update, options = {}) {
-        // $set 데이터에 대해 스키마 검증 적용
-        if (update?.$set) {
-            const schema = this.constructor.schema;
-            update.$set = await validateForUpdate(schema, update.$set);
-        }
-
-        const spec = { q: filter, u: update, multi: false };
-        if (options.upsert) spec.upsert = true;
-        if (options.arrayFilters) spec.arrayFilters = options.arrayFilters;
-        if (options.hint) spec.hint = options.hint;
-        if (options.collation) spec.collation = options.collation;
-
-        const cmd = { update: this.collection, updates: [spec] };
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        this._assertOk(result, 'updateOne');
-        return { ok: true, nModified: result?.nModified || 0, upserted: result?.upserted || null };
-    }
-
-    /**
-     * 다중 문서 수정
-     * @param {object} filter - 검색 조건
-     * @param {object} update - 수정 내용
-     * @param {object} [options={}] - 옵션
-     * @returns {Promise<object>} { ok, nModified }
-     */
-    async updateMany(filter, update, options = {}) {
-        // $set 데이터에 대해 스키마 검증 적용
-        if (update?.$set) {
-            const schema = this.constructor.schema;
-            update.$set = await validateForUpdate(schema, update.$set);
-        }
-
-        const spec = { q: filter, u: update, multi: true };
-        if (options.upsert) spec.upsert = true;
-        if (options.arrayFilters) spec.arrayFilters = options.arrayFilters;
-
-        const cmd = { update: this.collection, updates: [spec] };
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        this._assertOk(result, 'updateMany');
-        return { ok: true, nModified: result?.nModified || 0 };
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🗑️ 삭제 (Delete)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 단일 문서 삭제
-     * @param {object} filter - 검색 조건
-     * @returns {Promise<object>} { ok, n }
-     */
-    async deleteOne(filter) {
-        const cmd = { delete: this.collection, deletes: [{ q: filter, limit: 1 }] };
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        this._assertOk(result, 'deleteOne');
-        return { ok: true, n: result?.n || 0 };
-    }
-
-    /**
-     * 다중 문서 삭제
-     * @param {object} filter - 검색 조건
-     * @returns {Promise<object>} { ok, n }
-     */
-    async deleteMany(filter) {
-        const cmd = { delete: this.collection, deletes: [{ q: filter, limit: 0 }] };
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        this._assertOk(result, 'deleteMany');
-        return { ok: true, n: result?.n || 0 };
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📊 집계 (Aggregate)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * MongoDB Aggregation Pipeline 실행
-     * @param {object[]} pipeline - 파이프라인 스테이지 배열
-     * @param {object} [options={}] - 옵션 { collation, allowDiskUse }
-     * @returns {Promise<object[]>} 결과 배열
-     */
-    async aggregate(pipeline, options = {}) {
-        const cmd = { aggregate: this.collection, pipeline, cursor: {} };
-        if (options.collation) cmd.collation = options.collation;
-        if (options.allowDiskUse) cmd.allowDiskUse = true;
-
-        const result = await this._native.mongoCommand(JSON.stringify(cmd));
-        return result?.cursor?.firstBatch || [];
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔗 체이닝 호환 API (AlloyModel 상속)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // select, where, orWhere, whereIn, whereNull, limit, offset, orderBy,
-    // get, first, count, update, delete 등은 AlloyModel에서 상속
-
-    /**
-     * 체이닝 방식 삽입
-     * @param {object} data - 삽입할 데이터
-     * @returns {Promise<object>}
-     */
-    async save(data) {
-        const schema = this.constructor.schema;
-        data = await validateForSave(schema, data);
-        applyMongoDefaults(schema, data);
-
-        return await this._native.save(JSON.stringify(data));
-    }
-
-    /**
-     * Raw MongoDB 커맨드 실행
-     * @param {object} cmdObj - MongoDB 커맨드 객체
-     * @returns {Promise<object>}
-     */
-    async command(cmdObj) {
-        return await this._native.mongoCommand(JSON.stringify(cmdObj));
-    }
-
-    /**
-     * 응답 검증 (ok !== 1이면 에러)
-     * @private
-     */
-    _assertOk(result, operation) {
-        const ok = result?.ok;
-        if (ok !== 1 && ok !== 1.0) {
-            throw new AlloyError('MONGO_OPERATION_FAILED', `Mongo ${operation} Failed: ${result?.errmsg || 'Unknown error'}`, 500);
-        }
-    }
-}

package/src/data/AlloyRedisModel.js

@@ -1,158 +0,0 @@
-import native from '@alloy-framework/rust';
-
-/**
- * 🔴 Alloy Redis 모델
- * Redis의 자주 사용하는 명령을 직관적 API로 제공합니다.
- * Rust N-API의 AlloyRedis를 래핑합니다.
- *
- * @example
- * const redis = new AlloyRedisModel('cache');
- * await redis.set('key', 'value', 300);
- * const val = await redis.get('key');
- */
-export class AlloyRedisModel {
-    /**
-     * @param {string} [store='cache'] - alloy.conf에 정의된 Redis 스토어 이름
-     */
-    constructor(store = 'cache') {
-        /** @type {string} 스토어 이름 */
-        this.store = store;
-        /** @type {import('@alloy/rust').AlloyRedis} 네이티브 Redis 인스턴스 */
-        this._native = new native.AlloyRedis(store);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📝 String 명령
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 키-값 저장 (TTL 옵션)
-     * @param {string} key
-     * @param {string} value
-     * @param {number} [ttlSeconds] - TTL (초, 미지정 시 영구)
-     * @returns {Promise<void>}
-     */
-    async set(key, value, ttlSeconds) {
-        return await this._native.set(key, String(value), ttlSeconds || 0);
-    }
-
-    /**
-     * 키 조회
-     * @param {string} key
-     * @returns {Promise<string|null>}
-     */
-    async get(key) {
-        return await this._native.get(key);
-    }
-
-    /**
-     * 키 삭제
-     * @param {string} key
-     * @returns {Promise<void>}
-     */
-    async del(key) {
-        return await this._native.del(key);
-    }
-
-    /**
-     * 키 존재 여부
-     * @param {string} key
-     * @returns {Promise<boolean>}
-     */
-    async exists(key) {
-        return await this._native.exists(key);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📋 Hash 명령
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * Hash 필드 설정
-     * @param {string} key - Hash 키
-     * @param {string} field - 필드명
-     * @param {string} value - 값
-     * @returns {Promise<void>}
-     */
-    async hset(key, field, value) {
-        return await this._native.hset(key, field, String(value));
-    }
-
-    /**
-     * Hash 필드 조회
-     * @param {string} key
-     * @param {string} field
-     * @returns {Promise<string|null>}
-     */
-    async hget(key, field) {
-        return await this._native.hget(key, field);
-    }
-
-    /**
-     * Hash 필드 삭제
-     * @param {string} key
-     * @param {string} field
-     * @returns {Promise<void>}
-     */
-    async hdel(key, field) {
-        return await this._native.hdel(key, field);
-    }
-
-    /**
-     * Hash 전체 조회
-     * @param {string} key
-     * @returns {Promise<object>} 키-값 쌍
-     */
-    async hgetall(key) {
-        return await this._native.hgetall(key);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📝 List 명령
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * List 왼쪽 푸시
-     * @param {string} key
-     * @param {string} value
-     * @returns {Promise<void>}
-     */
-    async lpush(key, value) {
-        return await this._native.lpush(key, String(value));
-    }
-
-    /**
-     * List 오른쪽 푸시
-     * @param {string} key
-     * @param {string} value
-     * @returns {Promise<void>}
-     */
-    async rpush(key, value) {
-        return await this._native.rpush(key, String(value));
-    }
-
-    /**
-     * List 범위 조회
-     * @param {string} key
-     * @param {number} [start=0]
-     * @param {number} [stop=-1]
-     * @returns {Promise<string[]>}
-     */
-    async lrange(key, start = 0, stop = -1) {
-        return await this._native.lrange(key, start, stop);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔧 유틸리티
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * Raw Redis 명령 실행
-     * @param {string} cmd - 명령어 (예: 'TTL')
-     * @param {string[]} args - 인자 배열
-     * @returns {Promise<any>}
-     */
-    async command(cmd, ...args) {
-        return await this._native.rawCommand(cmd, args);
-    }
-}

package/src/data/GooseValidator.js

@@ -1,168 +0,0 @@
-import { AlloyError } from '../util/AlloyError.js';
-
-/**
- * 🦢 AlloyGoose 스키마 자동 검증기
- *
- * AlloyGoose 스키마의 `fields` 정의를 기반으로 데이터를 자동 검증합니다.
- * Joi 없이 기본적인 타입/필수값/길이/열거형 검증을 수행합니다.
- *
- * @example
- * GooseValidator.validateInsert(schema.fields, { username: 'admin', age: 25 });
- * GooseValidator.validateUpdate(schema.fields, { age: 30 });
- */
-export class GooseValidator {
-    /** 숫자 타입 목록 */
-    static #NUMBER_TYPES = new Set([
-        'int', 'bigint', 'mediumint', 'smallint', 'tinyint',
-        'float', 'double', 'decimal', 'number',
-    ]);
-
-    /** 문자열 타입 목록 */
-    static #STRING_TYPES = new Set([
-        'string', 'text', 'mediumtext', 'longtext', 'enum',
-    ]);
-
-    /**
-     * INSERT 용 검증 — required 필드 체크 포함
-     * @param {object} fields - AlloyGoose fields 정의
-     * @param {object} data - 삽입할 데이터
-     * @throws {Error} 검증 실패 시 (statusCode: 400)
-     */
-    static validateInsert(fields, data) {
-        const errors = [];
-
-        for (const [name, def] of Object.entries(fields)) {
-            // auto_increment PK는 검증 스킵
-            if (def.primary && def.auto_increment) continue;
-            // MongoDB _id는 시스템 생성
-            if (name === '_id') continue;
-
-            const value = data[name];
-
-            // ── required 체크 (INSERT 전용) ──
-            const isRequired = def.required === true || def.nullable === false;
-            if (isRequired && (value === undefined || value === null)) {
-                // default가 있으면 자동 주입되므로 패스
-                if (def.default !== undefined) continue;
-                errors.push(`'${name}' 필드는 필수입니다`);
-                continue;
-            }
-
-            // 값이 없으면 이후 타입 체크 불필요
-            if (value === undefined || value === null) continue;
-
-            // ── 타입 체크 ──
-            this.#checkType(name, def, value, errors);
-
-            // ── 길이 체크 ──
-            this.#checkLength(name, def, value, errors);
-
-            // ── enum 체크 ──
-            this.#checkEnum(name, def, value, errors);
-
-            // ── 필드별 Joi 추가 검증 ──
-            this.#checkValidator(name, def, value, errors);
-        }
-
-        if (errors.length > 0) {
-            throw new AlloyError('VALIDATION_ERROR', `Validation Error: ${errors.join(', ')}`, 400);
-        }
-    }
-
-    /**
-     * UPDATE 용 검증 — required 무시, 제공된 필드만 검증
-     * @param {object} fields - AlloyGoose fields 정의
-     * @param {object} data - 수정할 데이터
-     * @throws {Error} 검증 실패 시 (statusCode: 400)
-     */
-    static validateUpdate(fields, data) {
-        const errors = [];
-
-        for (const [name, value] of Object.entries(data)) {
-            const def = fields[name];
-            // 스키마에 없는 필드는 건너뜀 (MongoDB 유연성)
-            if (!def) continue;
-            // null 허용 체크
-            if (value === null) {
-                if (def.nullable === false || def.required === true) {
-                    errors.push(`'${name}' 필드는 NULL일 수 없습니다`);
-                }
-                continue;
-            }
-
-            this.#checkType(name, def, value, errors);
-            this.#checkLength(name, def, value, errors);
-            this.#checkEnum(name, def, value, errors);
-            this.#checkValidator(name, def, value, errors);
-        }
-
-        if (errors.length > 0) {
-            throw new AlloyError('VALIDATION_ERROR', `Validation Error: ${errors.join(', ')}`, 400);
-        }
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔒 Private 검증 헬퍼
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    static #checkType(name, def, value, errors) {
-        const ft = def.type;
-        if (!ft) return;
-
-        if (this.#NUMBER_TYPES.has(ft)) {
-            if (typeof value !== 'number' || Number.isNaN(value)) {
-                errors.push(`'${name}' 필드는 숫자여야 합니다 (type: ${ft})`);
-            }
-        } else if (this.#STRING_TYPES.has(ft)) {
-            if (typeof value !== 'string') {
-                errors.push(`'${name}' 필드는 문자열이어야 합니다 (type: ${ft})`);
-            }
-        } else if (ft === 'boolean') {
-            if (typeof value !== 'boolean') {
-                errors.push(`'${name}' 필드는 boolean이어야 합니다`);
-            }
-        } else if (ft === 'json' || ft === 'object') {
-            if (typeof value !== 'object') {
-                errors.push(`'${name}' 필드는 객체여야 합니다 (type: ${ft})`);
-            }
-        } else if (ft === 'array') {
-            if (!Array.isArray(value)) {
-                errors.push(`'${name}' 필드는 배열이어야 합니다`);
-            }
-        } else if (ft === 'datetime' || ft === 'timestamp' || ft === 'date') {
-            // 문자열 또는 Date 객체 허용
-            if (typeof value !== 'string' && !(value instanceof Date)) {
-                errors.push(`'${name}' 필드는 날짜 문자열 또는 Date 객체여야 합니다`);
-            }
-        }
-    }
-
-    /** 길이 체크 제외 타입 (fractional seconds precision) */
-    static #SKIP_LENGTH_TYPES = new Set(['datetime', 'timestamp', 'date']);
-
-    static #checkLength(name, def, value, errors) {
-        if (this.#SKIP_LENGTH_TYPES.has(def.type)) return;
-        if (def.length && typeof value === 'string' && value.length > def.length) {
-            errors.push(`'${name}' 필드는 ${def.length}자 이하여야 합니다 (현재: ${value.length}자)`);
-        }
-    }
-
-    static #checkEnum(name, def, value, errors) {
-        const enumValues = def.enum || def.enum_values;
-        if (enumValues && Array.isArray(enumValues)) {
-            if (!enumValues.includes(value)) {
-                errors.push(`'${name}' 필드는 [${enumValues.join(', ')}] 중 하나여야 합니다`);
-            }
-        }
-    }
-
-    static #checkValidator(name, def, value, errors) {
-        if (def.validator && typeof def.validator.validate === 'function') {
-            const { error } = def.validator.validate(value);
-            if (error) {
-                const details = error.details?.map(d => d.message).join(', ') || error.message;
-                errors.push(`'${name}': ${details}`);
-            }
-        }
-    }
-}

package/src/data/index.js

@@ -1,6 +0,0 @@
-/**
- * 📊 데이터 계층 통합 export
- */
-export { AlloyModel, AlloyMariaModel } from './AlloyModel.js';
-export { AlloyMongoModel } from './AlloyMongoModel.js';
-export { AlloyRedisModel } from './AlloyRedisModel.js';

package/src/data/validationHelper.js

@@ -1,79 +0,0 @@
-/**
- * 🔧 검증/기본값 공통 헬퍼
- * AlloyModel, AlloyMongoModel에서 중복되던 검증 + 기본값 로직을 통합합니다.
- */
-
-/**
- * INSERT용 데이터 검증 (AlloyGoose + legacy Joi 자동 분기)
- * @param {object|null} schema - 모델의 static schema
- * @param {object} data - 삽입할 데이터
- * @returns {object} 검증/정제된 데이터
- */
-export async function validateForSave(schema, data) {
-    if (!schema) return data;
-
-    // 1) AlloyGoose 스키마 (fields 기반)
-    if (schema.fields && typeof schema.fields === 'object') {
-        const { GooseValidator } = await import('./GooseValidator.js');
-        GooseValidator.validateInsert(schema.fields, data);
-        return data;
-    }
-
-    // 2) legacy Joi 스키마 (validate 메서드)
-    if (typeof schema.validate === 'function') {
-        const { Validator } = await import('../http/Validator.js');
-        return Validator.validate(schema, data);
-    }
-
-    return data;
-}
-
-/**
- * UPDATE용 데이터 검증 (AlloyGoose + legacy Joi 자동 분기)
- * @param {object|null} schema - 모델의 static schema
- * @param {object} data - 수정할 데이터
- * @returns {object} 검증/정제된 데이터
- */
-export async function validateForUpdate(schema, data) {
-    if (!schema) return data;
-
-    // 1) AlloyGoose 스키마 (fields 기반 — 제공된 필드만 검증)
-    if (schema.fields && typeof schema.fields === 'object') {
-        const { GooseValidator } = await import('./GooseValidator.js');
-        GooseValidator.validateUpdate(schema.fields, data);
-        return data;
-    }
-
-    // 2) legacy Joi 스키마 (partial 검증)
-    if (typeof schema.validate === 'function') {
-        const { Validator } = await import('../http/Validator.js');
-        return Validator.validate(schema, data, true);
-    }
-
-    return data;
-}
-
-/**
- * MongoDB 기본값 자동 주입 (DDL DEFAULT 없으므로 앱 레벨에서 처리)
- * @param {object|null} schema - 모델의 static schema
- * @param {object} data - 삽입할 데이터 (in-place 수정)
- */
-export function applyMongoDefaults(schema, data) {
-    if (!schema?.fields || typeof schema.fields !== 'object') return;
-
-    for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-        if (fieldName === '_id') continue;
-        if (data[fieldName] !== undefined) continue;
-
-        if (fieldDef.default !== undefined) {
-            if (fieldDef.default === 'CURRENT_TIMESTAMP' || fieldDef.default === 'NOW()') {
-                data[fieldName] = new Date().toISOString();
-            } else {
-                data[fieldName] = fieldDef.default;
-            }
-        } else {
-            // default 미지정 필드는 null로 주입 (MongoDB 문서에 필드 존재 보장)
-            data[fieldName] = null;
-        }
-    }
-}