@alloy-framework/core 0.3.0 → 0.14.0

package/src/config/AlloyConfig.js

@@ -1,131 +0,0 @@
-import native from '@alloy-framework/rust';
-
-/** @type {object|null} 캐싱된 설정 객체 (alloy.conf 구조에 맞게 재매핑됨) */
-let cachedConfig = null;
-
-/**
- * 🔧 AlloyConfig — alloy.conf 설정값 접근 모듈 (싱글턴)
- *
- * Rust 네이티브 엔진이 파싱한 alloy.conf 설정을 JS에서 사용할 수 있도록 노출합니다.
- * alloy.conf에 쓴 키 구조 그대로 접근할 수 있습니다.
- * boot_system() 이후에 호출해야 합니다.
- *
- * @example
- * import { AlloyConfig } from '@alloy-framework/core';
- *
- * // alloy.conf 구조 그대로 접근
- * AlloyConfig.get('server.listen');           // 4100
- * AlloyConfig.get('server.workers');          // 4
- * AlloyConfig.get('logging.level');           // "info"
- * AlloyConfig.get('logging.dir');             // "logs"
- * AlloyConfig.get('websocket.path');          // "/ws-backend"
- * AlloyConfig.get('session.cookie_name');     // "alloy_starter_sess"
- * AlloyConfig.get('nats.prefix');             // "ws-backend"
- * AlloyConfig.get('i18n.default_locale');     // "ko"
- * AlloyConfig.get('security.master_secret');  // "alloy-starter-backend-secret-32ch"
- * AlloyConfig.get('custom.local_tz_offset');  // 9  (앱 전용 변수)
- *
- * // database는 이름으로 조회
- * AlloyConfig.getDatabase('session');         // { name, driver, url, max_pool_size }
- * AlloyConfig.getDatabase('maria_main');      // { name, driver, url, max_pool_size }
- */
-export class AlloyConfig {
-    /**
-     * Rust 구조체 JSON을 alloy.conf 구조에 맞게 재매핑합니다.
-     * @param {object} raw - Rust에서 직렬화된 원본 설정 객체
-     * @returns {object} alloy.conf 구조에 맞는 설정 객체
-     * @private
-     */
-    static _remap(raw) {
-        return {
-            // server {} 블록 — logging/websocket 제외한 서버 설정
-            server: {
-                listen: raw.server?.port,
-                port: raw.server?.port,
-                workers: raw.server?.workers,
-                templates_dir: raw.server?.templates_dir,
-                template_cache_enabled: raw.server?.template_cache_enabled,
-                request_timeout_seconds: raw.server?.request_timeout_seconds,
-            },
-            // logging {} 블록 — alloy.conf에서 독립 블록
-            logging: raw.server?.logging,
-            // websocket — alloy.conf에서 set $alloy_ws_* 로 설정
-            websocket: raw.server?.websocket,
-            // model — alloy.conf에서 server {} 내 model_schema_sync/strict
-            model: raw.model,
-            // security — set $alloy_cors_*, $alloy_encrypt_traffic 등
-            security: raw.security,
-            // session — set $alloy_session_*
-            session: raw.session,
-            // databases — database <name> {} 블록들 (배열)
-            databases: raw.databases,
-            // nats {} 블록
-            nats: raw.nats,
-            // i18n {} 블록
-            i18n: raw.i18n,
-            // upload {} 블록
-            upload: raw.upload,
-            // location 블록들
-            static_files: raw.static_files,
-            // rate_limit — set $alloy_rate_limit_*
-            rate_limit: raw.rate_limit,
-            // limits — client_max_body_size 등
-            limits: raw.limits,
-            // custom {} 블록 — 앱 전용 변수 (Rust 빌드 없이 추가/변경 가능)
-            custom: raw.custom || {},
-        };
-    }
-
-    /**
-     * 설정 전체를 로드하여 캐싱합니다.
-     * boot_system() 이후에 호출해야 합니다.
-     * @returns {object} alloy.conf 구조에 맞게 재매핑된 설정 객체
-     */
-    static load() {
-        if (!cachedConfig) {
-            const json = native.getConfig();
-            const raw = JSON.parse(json);
-            cachedConfig = AlloyConfig._remap(raw);
-        }
-        return cachedConfig;
-    }
-
-    /**
-     * 캐시를 무효화하고 설정을 다시 로드합니다.
-     * @returns {object} 새로 로드된 설정 객체
-     */
-    static reload() {
-        cachedConfig = null;
-        return AlloyConfig.load();
-    }
-
-    /**
-     * 특정 키의 설정값을 반환합니다.
-     * alloy.conf에 쓴 구조 그대로 dot notation으로 접근합니다.
-     * @param {string} key - dot notation 키 (예: 'logging.level', 'session.cookie_name')
-     * @param {*} defaultValue - 키가 없을 때 반환할 기본값
-     * @returns {*} 설정값
-     */
-    static get(key, defaultValue = undefined) {
-        const config = AlloyConfig.load();
-        // dot notation 경로 탐색 (예: 'logging.level' → config.logging.level)
-        const parts = key.split('.');
-        let current = config;
-        for (const part of parts) {
-            if (current == null || typeof current !== 'object') return defaultValue;
-            current = current[part];
-        }
-        return current !== undefined ? current : defaultValue;
-    }
-
-    /**
-     * 이름으로 데이터베이스 설정을 조회합니다.
-     * alloy.conf의 `database <name> {}` 블록에 대응합니다.
-     * @param {string} name - 데이터베이스 이름 (예: 'maria_main', 'session', 'cache')
-     * @returns {object|undefined} { name, driver, url, max_pool_size } 또는 undefined
-     */
-    static getDatabase(name) {
-        const config = AlloyConfig.load();
-        return config.databases?.find(db => db.name === name);
-    }
-}

package/src/data/AlloyModel.js

@@ -1,405 +0,0 @@
-import native from '@alloy-framework/rust';
-import { validateForSave, validateForUpdate, applyMongoDefaults } from './validationHelper.js';
-
-/**
- * 📊 Alloy SQL 모델 (MySQL / MariaDB / PostgreSQL)
- * Rust SeaORM 기반 체이닝 쿼리 빌더와 CRUD 메서드를 제공합니다.
- *
- * @example
- * // 모델 정의
- * class Users extends AlloyModel {
- *     constructor() { super('users'); }
- *     static schema = Joi.object({ username: Joi.string().required() });
- * }
- *
- * // 체이닝 쿼리
- * const users = await new Users().select(['id', 'username']).where('id', '>', '10').limit(20).get();
- */
-export class AlloyModel {
-    /**
-     * @param {string} table - 테이블 이름
-     * @param {string} [store='primary'] - alloy.conf에 정의된 SQL 스토어 이름
-     */
-    constructor(table, store = 'primary') {
-        /** @type {string} 테이블 이름 */
-        this.table = table;
-        /** @type {string} 스토어 이름 */
-        this.store = store;
-        /** @type {import('@alloy/rust').AlloyModel} 네이티브 모델 */
-        this._native = new native.AlloyModel(table, store);
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔗 체이닝 쿼리 빌더
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 조회할 필드 지정
-     * @param {string[]} fields - 필드 배열
-     * @returns {this}
-     */
-    select(fields) {
-        this._native.select(fields);
-        return this;
-    }
-
-    /**
-     * WHERE 조건 추가 (AND)
-     * @param {string} field - 필드명
-     * @param {string} opOrValue - 연산자 또는 값 (2인수 시 값, 3인수 시 연산자)
-     * @param {string|number|boolean} [value] - 비교 값 (3인수 시)
-     * @returns {this}
-     */
-    where(field, opOrValue, value) {
-        if (value === undefined) {
-            // 2인수: .where('field', value) → op = '='
-            this._native.where(field, '=', JSON.stringify(opOrValue));
-        } else {
-            this._native.where(field, opOrValue, JSON.stringify(value));
-        }
-        return this;
-    }
-
-    /**
-     * OR WHERE 조건 추가 (이전 조건과 OR로 결합)
-     * @param {string} field - 필드명
-     * @param {string} opOrValue - 연산자 또는 값
-     * @param {string|number|boolean} [value] - 비교 값 (3인수 시)
-     * @returns {this}
-     */
-    orWhere(field, opOrValue, value) {
-        if (value === undefined) {
-            this._native.orWhere(field, '=', JSON.stringify(opOrValue));
-        } else {
-            this._native.orWhere(field, opOrValue, JSON.stringify(value));
-        }
-        return this;
-    }
-
-    /**
-     * Raw SQL WHERE 조건 추가 (플레이스홀더: ?)
-     * SQL 백엔드 전용 — MongoDB에서는 무시됨
-     * @param {string} rawSql - Raw SQL 조건문 (예: '(col1 LIKE ? OR col2 LIKE ?)')
-     * @param {Array<string>} [params=[]] - 바인딩 파라미터
-     * @returns {this}
-     */
-    whereRaw(rawSql, params = []) {
-        this._native.whereRaw(rawSql, JSON.stringify(params));
-        return this;
-    }
-
-    /**
-     * WHERE field IN (values) 조건
-     * @param {string} field - 필드명
-     * @param {Array<string|number>} values - 값 배열
-     * @returns {this}
-     */
-    whereIn(field, values) {
-        this._native.whereIn(field, JSON.stringify(values));
-        return this;
-    }
-
-    /**
-     * WHERE field NOT IN (values) 조건
-     * @param {string} field - 필드명
-     * @param {Array<string|number>} values - 값 배열
-     * @returns {this}
-     */
-    whereNotIn(field, values) {
-        this._native.whereNotIn(field, JSON.stringify(values));
-        return this;
-    }
-
-    /**
-     * WHERE field IS NULL 조건
-     * @param {string} field - 필드명
-     * @returns {this}
-     */
-    whereNull(field) {
-        this._native.whereNull(field);
-        return this;
-    }
-
-    /**
-     * WHERE field IS NOT NULL 조건
-     * @param {string} field - 필드명
-     * @returns {this}
-     */
-    whereNotNull(field) {
-        this._native.whereNotNull(field);
-        return this;
-    }
-
-    /**
-     * WHERE field BETWEEN min AND max 조건
-     * @param {string} field - 필드명
-     * @param {string|number} min - 최솟값
-     * @param {string|number} max - 최댓값
-     * @returns {this}
-     */
-    whereBetween(field, min, max) {
-        this._native.whereBetween(field, JSON.stringify(min), JSON.stringify(max));
-        return this;
-    }
-
-    /**
-     * WHERE field IN (SELECT subColumn FROM subTable WHERE ...conditions) 서브쿼리 조건
-     * @param {string} field - 메인 테이블 필드명
-     * @param {string} subTable - 서브쿼리 테이블명
-     * @param {string} subColumn - 서브쿼리 SELECT 컬럼명
-     * @param {Array<{field: string, op: string, value?: any}>} conditions - 서브쿼리 WHERE 조건 배열
-     * @returns {this}
-     * @example
-     * // _id IN (SELECT notification_id FROM notification_reads WHERE user_id = 5)
-     * .whereInSub('_id', 'notification_reads', 'notification_id', [
-     *     { field: 'user_id', op: '=', value: 5 }
-     * ])
-     */
-    whereInSub(field, subTable, subColumn, conditions = []) {
-        this._native.whereInSub(field, subTable, subColumn, JSON.stringify(conditions));
-        return this;
-    }
-
-    /**
-     * WHERE field NOT IN (SELECT subColumn FROM subTable WHERE ...conditions) 서브쿼리 조건
-     * @param {string} field - 메인 테이블 필드명
-     * @param {string} subTable - 서브쿼리 테이블명
-     * @param {string} subColumn - 서브쿼리 SELECT 컬럼명
-     * @param {Array<{field: string, op: string, value?: any}>} conditions - 서브쿼리 WHERE 조건 배열
-     * @returns {this}
-     * @example
-     * // _id NOT IN (SELECT notification_id FROM notification_reads WHERE user_id = 5 AND deleted_at IS NOT NULL)
-     * .whereNotInSub('_id', 'notification_reads', 'notification_id', [
-     *     { field: 'user_id', op: '=', value: 5 },
-     *     { field: 'deleted_at', op: 'IS NOT NULL' }
-     * ])
-     */
-    whereNotInSub(field, subTable, subColumn, conditions = []) {
-        this._native.whereNotInSub(field, subTable, subColumn, JSON.stringify(conditions));
-        return this;
-    }
-
-    /**
-     * SELECT DISTINCT
-     * @returns {this}
-     */
-    distinct() {
-        this._native.distinct();
-        return this;
-    }
-
-    /**
-     * GROUP BY 필드
-     * @param {string} field - 그룹핑 필드
-     * @returns {this}
-     */
-    groupBy(field) {
-        this._native.groupBy(field);
-        return this;
-    }
-
-    /**
-     * HAVING 조건 (GROUP BY 후 필터)
-     * @param {string} field - 필드명
-     * @param {string} op - 연산자
-     * @param {string|number} value - 비교 값
-     * @returns {this}
-     */
-    having(field, op, value) {
-        this._native.having(field, op, JSON.stringify(value));
-        return this;
-    }
-
-    /**
-     * 결과 제한
-     * @param {number} count - 제한 수
-     * @returns {this}
-     */
-    limit(count) {
-        this._native.limit(count);
-        return this;
-    }
-
-    /**
-     * 결과 오프셋 (페이지네이션용)
-     * @param {number} count - 건너뛸 행 수
-     * @returns {this}
-     */
-    offset(count) {
-        this._native.offset(count);
-        return this;
-    }
-
-    /**
-     * 정렬
-     * @param {string} field - 정렬 필드
-     * @param {'ASC'|'DESC'} [direction='ASC'] - 정렬 방향
-     * @returns {this}
-     */
-    orderBy(field, direction = 'ASC') {
-        this._native.orderBy(field, direction);
-        return this;
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 📝 CRUD
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * SELECT 쿼리 실행
-     * @returns {Promise<any[]>} 결과 배열
-     */
-    async get() {
-        try {
-            return await this._native.get();
-        } finally {
-            this._native.reset();
-        }
-    }
-
-    /**
-     * INSERT 쿼리 실행
-     * @param {object} data - 삽입할 데이터
-     * @returns {Promise<object>} { status: 'ok', last_insert_id: ... }
-     */
-    async save(data) {
-        const schema = this.constructor.schema;
-        data = await validateForSave(schema, data);
-
-        // MongoDB 기본값 주입 (MariaDB는 DDL DEFAULT를 DB 엔진이 자동 처리)
-        if (this.store.startsWith('mongo')) {
-            applyMongoDefaults(schema, data);
-        }
-
-        try {
-            return await this._native.save(JSON.stringify(data));
-        } finally {
-            this._native.reset();
-        }
-    }
-
-    /**
-     * UPDATE 쿼리 실행 (where 조건 필수)
-     * @param {object} data - 수정할 데이터
-     * @returns {Promise<object>} { status: 'ok', rows_affected: ... }
-     */
-    async update(data) {
-        const schema = this.constructor.schema;
-        data = await validateForUpdate(schema, data);
-
-        try {
-            return await this._native.update(JSON.stringify(data));
-        } finally {
-            this._native.reset();
-        }
-    }
-
-    /**
-     * DELETE 쿼리 실행 (where 조건 필수)
-     * @returns {Promise<object>} { status: 'ok', rows_affected: ... }
-     */
-    async delete() {
-        try {
-            return await this._native.delete();
-        } finally {
-            this._native.reset();
-        }
-    }
-
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    // 🔧 편의 메서드 (Convenience)
-    // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-    /**
-     * 첫 번째 행만 반환 (limit 1 + 배열 해제)
-     * @returns {Promise<object|null>} 첫 번째 결과 또는 null
-     */
-    async first() {
-        this.limit(1);
-        const rows = await this.get();
-        return rows[0] || null;
-    }
-
-    /**
-     * 집계 공통 헬퍼 (내부용)
-     * @param {string} fn - 집계 함수 ('count' | 'sum' | 'avg' | 'min' | 'max')
-     * @param {string} field - 대상 필드명 ('*' for count)
-     * @returns {Promise<number>} 집계 결과
-     * @private
-     */
-    async _aggregate(fn, field) {
-        try {
-            const row = await this._native.aggregate(fn, field);
-            return row?.result || 0;
-        } finally {
-            this._native.reset();
-        }
-    }
-
-    /**
-     * 행 수 카운트 (SQL / MongoDB 모두 지원)
-     * @returns {Promise<number>} 전체 행 수
-     */
-    count() { return this._aggregate('count', '*'); }
-
-    /**
-     * SUM 집계 (SQL / MongoDB 모두 지원)
-     * @param {string} field - 합산할 필드명
-     * @returns {Promise<number>} 합계
-     */
-    sum(field) { return this._aggregate('sum', field); }
-
-    /**
-     * AVG 집계 (SQL / MongoDB 모두 지원)
-     * @param {string} field - 평균낼 필드명
-     * @returns {Promise<number>} 평균값
-     */
-    avg(field) { return this._aggregate('avg', field); }
-
-    /**
-     * MIN 집계 (SQL / MongoDB 모두 지원)
-     * @param {string} field - 최솟값 필드명
-     * @returns {Promise<number>} 최솟값
-     */
-    min(field) { return this._aggregate('min', field); }
-
-    /**
-     * MAX 집계 (SQL / MongoDB 모두 지원)
-     * @param {string} field - 최댓값 필드명
-     * @returns {Promise<number>} 최댓값
-     */
-    max(field) { return this._aggregate('max', field); }
-
-    /**
-     * Raw SQL 쿼리 실행
-     * @param {string} sql - SQL 문자열 (placeholder: ?)
-     * @param {Array} [params=[]] - 바인딩 파라미터
-     * @returns {Promise<object[]>} 결과 배열
-     */
-    async query(sql, params = []) {
-        try {
-            return await this._native.query(sql, JSON.stringify(params));
-        } finally {
-            this._native.reset();
-        }
-    }
-
-    /**
-     * 스토어드 프로시저 호출
-     * @param {string} name - 프로시저 이름
-     * @param {Array} [params=[]] - 프로시저 인자
-     * @returns {Promise<object[]>} 결과 배열
-     */
-    async callProcedure(name, params = []) {
-        try {
-            return await this._native.callProcedure(name, JSON.stringify(params));
-        } finally {
-            this._native.reset();
-        }
-    }
-}
-
-/**
- * AlloyMariaModel — AlloyModel의 명시적 별칭
- */
-export const AlloyMariaModel = AlloyModel;