@stonyx/orm 0.2.1-beta.83 → 0.2.1-beta.84

package/dist/aggregates.d.ts

@@ -0,0 +1,21 @@
+type AggregateType = 'count' | 'avg' | 'sum' | 'min' | 'max';
+interface AggregateRecord {
+    __data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare class AggregateProperty {
+    readonly __kind: "AggregateProperty";
+    readonly aggregateType: AggregateType;
+    readonly relationship: string | undefined;
+    readonly field: string | undefined;
+    readonly mysqlFunction: string;
+    readonly resultType: 'float' | 'number';
+    constructor(aggregateType: AggregateType, relationship?: string, field?: string);
+    compute(relatedRecords: AggregateRecord[]): number | null;
+}
+export declare function count(relationship: string): AggregateProperty;
+export declare function avg(relationshipOrField: string, field?: string): AggregateProperty;
+export declare function sum(relationshipOrField: string, field?: string): AggregateProperty;
+export declare function min(relationshipOrField: string, field?: string): AggregateProperty;
+export declare function max(relationshipOrField: string, field?: string): AggregateProperty;
+export {};

package/dist/aggregates.js

@@ -0,0 +1,90 @@
+export class AggregateProperty {
+    __kind = 'AggregateProperty';
+    aggregateType;
+    relationship;
+    field;
+    mysqlFunction;
+    resultType;
+    constructor(aggregateType, relationship, field) {
+        this.aggregateType = aggregateType;
+        this.relationship = relationship;
+        this.field = field;
+        this.mysqlFunction = aggregateType.toUpperCase();
+        this.resultType = aggregateType === 'avg' ? 'float' : 'number';
+    }
+    compute(relatedRecords) {
+        if (!relatedRecords || !Array.isArray(relatedRecords) || relatedRecords.length === 0) {
+            if (this.aggregateType === 'min' || this.aggregateType === 'max')
+                return null;
+            return 0;
+        }
+        switch (this.aggregateType) {
+            case 'count':
+                return relatedRecords.length;
+            case 'sum':
+                return relatedRecords.reduce((acc, record) => {
+                    const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+                    return acc + (isNaN(val) ? 0 : val);
+                }, 0);
+            case 'avg': {
+                let sum = 0;
+                let count = 0;
+                for (const record of relatedRecords) {
+                    const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+                    if (!isNaN(val)) {
+                        sum += val;
+                        count++;
+                    }
+                }
+                return count === 0 ? 0 : sum / count;
+            }
+            case 'min': {
+                let min = null;
+                for (const record of relatedRecords) {
+                    const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+                    if (!isNaN(val) && (min === null || val < min))
+                        min = val;
+                }
+                return min;
+            }
+            case 'max': {
+                let max = null;
+                for (const record of relatedRecords) {
+                    const val = parseFloat(record?.__data?.[this.field] ?? record?.[this.field]);
+                    if (!isNaN(val) && (max === null || val > max))
+                        max = val;
+                }
+                return max;
+            }
+            default:
+                return null;
+        }
+    }
+}
+export function count(relationship) {
+    return new AggregateProperty('count', relationship);
+}
+export function avg(relationshipOrField, field) {
+    if (field !== undefined) {
+        return new AggregateProperty('avg', relationshipOrField, field);
+    }
+    return new AggregateProperty('avg', undefined, relationshipOrField);
+}
+export function sum(relationshipOrField, field) {
+    if (field !== undefined) {
+        return new AggregateProperty('sum', relationshipOrField, field);
+    }
+    return new AggregateProperty('sum', undefined, relationshipOrField);
+}
+export function min(relationshipOrField, field) {
+    if (field !== undefined) {
+        return new AggregateProperty('min', relationshipOrField, field);
+    }
+    return new AggregateProperty('min', undefined, relationshipOrField);
+}
+export function max(relationshipOrField, field) {
+    if (field !== undefined) {
+        return new AggregateProperty('max', relationshipOrField, field);
+    }
+    return new AggregateProperty('max', undefined, relationshipOrField);
+}

package/dist/attr.d.ts

@@ -0,0 +1,2 @@
+import ModelProperty from './model-property.js';
+export default function attr(type?: string, defaultValue?: unknown): ModelProperty;

package/dist/attr.js

@@ -0,0 +1,22 @@
+import ModelProperty from './model-property.js';
+export default function attr(type, defaultValue) {
+    const modelProp = new ModelProperty(type, defaultValue);
+    return new Proxy(modelProp, {
+        get(target, prop, receiver) {
+            if (prop === 'valueOf' || prop === 'toString') {
+                return () => target.value;
+            }
+            if (prop in target) {
+                return Reflect.get(target, prop, receiver);
+            }
+            return target.value;
+        },
+        set(target, prop, value, receiver) {
+            if (prop === 'value') {
+                target.value = value;
+                return true;
+            }
+            return Reflect.set(target, prop, value, receiver);
+        }
+    });
+}

package/dist/belongs-to.d.ts

@@ -0,0 +1,11 @@
+import type { SourceRecord } from './types/orm-types.js';
+interface BelongsToOptions {
+    _relationshipKey?: string;
+    [key: string]: unknown;
+}
+type RelationshipHandler = ((sourceRecord: SourceRecord, rawData: unknown, options: BelongsToOptions) => unknown) & {
+    __relatedModelName: string;
+    __relationshipType: 'belongsTo';
+};
+export default function belongsTo(modelName: string): RelationshipHandler;
+export {};

package/dist/belongs-to.js

@@ -0,0 +1,58 @@
+import { createRecord, store } from '@stonyx/orm';
+import { getRelationships, getHasManyRegistry, getPendingRegistry, getPendingBelongsToRegistry } from './relationships.js';
+function getOrSet(map, key, defaultValue) {
+    if (!map.has(key))
+        map.set(key, defaultValue);
+    return map.get(key);
+}
+export default function belongsTo(modelName) {
+    const hasManyRelationships = getHasManyRegistry();
+    const pendingHasManyQueue = getPendingRegistry();
+    const pendingBelongsToQueue = getPendingBelongsToRegistry();
+    const fn = (sourceRecord, rawData, options) => {
+        if (!rawData)
+            return null;
+        const { __name: sourceModelName } = sourceRecord.__model;
+        const relationshipId = sourceRecord.id;
+        const relationshipKey = options._relationshipKey;
+        const relationship = getRelationships('belongsTo', sourceModelName, modelName, relationshipId);
+        const modelStore = store.get(modelName);
+        // Try to get existing record
+        let output;
+        if (typeof rawData === 'object') {
+            output = createRecord(modelName, rawData, options);
+        }
+        else if (modelStore) {
+            output = modelStore.get(rawData);
+        }
+        // If not found and is a string ID, register as pending
+        if (!output && typeof rawData !== 'object') {
+            const targetId = rawData;
+            // Register pending belongsTo
+            const modelPendingMap = getOrSet(pendingBelongsToQueue, modelName, new Map());
+            const targetPendingArray = getOrSet(modelPendingMap, targetId, []);
+            targetPendingArray.push({
+                sourceRecord,
+                sourceModelName,
+                relationshipKey,
+                relationshipId
+            });
+            relationship.set(relationshipId, null);
+            return null;
+        }
+        relationship.set(relationshipId, output || {});
+        // Populate hasMany side if the relationship is defined
+        const otherSide = hasManyRelationships.get(modelName)?.get(sourceModelName)?.get(output?.id);
+        if (otherSide) {
+            otherSide.push(sourceRecord);
+            // Remove pending queue if it was just fulfilled
+            const pendingModelRelationships = pendingHasManyQueue.get(sourceModelName);
+            if (pendingModelRelationships)
+                pendingModelRelationships.delete(relationshipId);
+        }
+        return output;
+    };
+    Object.defineProperty(fn, '__relatedModelName', { value: modelName });
+    Object.defineProperty(fn, '__relationshipType', { value: 'belongsTo' });
+    return fn;
+}

package/dist/cli.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for ORM database operations.
+ *
+ * Performs CRUD operations on the JSON database without requiring
+ * the full Stonyx bootstrap. Supports both file and directory modes.
+ *
+ * Usage:
+ *   stonyx-orm create <collection> <json-data>
+ *   stonyx-orm list <collection>
+ *   stonyx-orm get <collection> <id>
+ *   stonyx-orm delete <collection> <id>
+ *
+ * Configuration (environment variables):
+ *   DB_MODE      -- 'file' or 'directory' (default: 'directory')
+ *   DB_PATH      -- Path to db.json (default: 'db.json')
+ *   DB_DIRECTORY  -- Directory name for collection files (default: 'db')
+ *
+ * Configuration (CLI flag):
+ *   --config <path>  -- Path to a JSON config file with { mode, dbPath, directory }
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for ORM database operations.
+ *
+ * Performs CRUD operations on the JSON database without requiring
+ * the full Stonyx bootstrap. Supports both file and directory modes.
+ *
+ * Usage:
+ *   stonyx-orm create <collection> <json-data>
+ *   stonyx-orm list <collection>
+ *   stonyx-orm get <collection> <id>
+ *   stonyx-orm delete <collection> <id>
+ *
+ * Configuration (environment variables):
+ *   DB_MODE      -- 'file' or 'directory' (default: 'directory')
+ *   DB_PATH      -- Path to db.json (default: 'db.json')
+ *   DB_DIRECTORY  -- Directory name for collection files (default: 'db')
+ *
+ * Configuration (CLI flag):
+ *   --config <path>  -- Path to a JSON config file with { mode, dbPath, directory }
+ */
+import StandaloneDB from './standalone-db.js';
+import fs from 'fs/promises';
+const USAGE = `Usage: stonyx-orm <command> [options]
+
+Commands:
+  create <collection> <json-data>   Create a record
+  list   <collection>               List all records
+  get    <collection> <id>          Get a record by ID
+  delete <collection> <id>          Delete a record by ID
+
+Options:
+  --config <path>   Path to JSON config file
+  --help            Show this help message
+
+Environment variables:
+  DB_MODE       'file' or 'directory' (default: 'directory')
+  DB_PATH       Path to db.json (default: 'db.json')
+  DB_DIRECTORY  Directory name for collection files (default: 'db')`;
+async function loadConfig(args) {
+    const config = {};
+    // Check for --config flag
+    const configIndex = args.indexOf('--config');
+    if (configIndex !== -1 && args[configIndex + 1]) {
+        const configPath = args[configIndex + 1];
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            Object.assign(config, JSON.parse(content));
+        }
+        catch (err) {
+            console.error(`Error reading config file '${configPath}': ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        // Remove --config and its value from args
+        args.splice(configIndex, 2);
+    }
+    // Environment variables override config file, config file overrides defaults
+    return {
+        mode: (process.env.DB_MODE || config.mode || 'directory'),
+        dbPath: process.env.DB_PATH || config.dbPath || 'db.json',
+        directory: process.env.DB_DIRECTORY || config.directory || 'db',
+    };
+}
+function parseArgs(argv) {
+    // Strip node binary and script path
+    const args = argv.slice(2);
+    if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+        console.log(USAGE);
+        process.exit(0);
+    }
+    return args;
+}
+async function run() {
+    const args = parseArgs(process.argv);
+    const config = await loadConfig(args);
+    const db = new StandaloneDB(config);
+    const [command, collection, ...rest] = args;
+    if (!command) {
+        console.error('Error: No command specified.\n');
+        console.log(USAGE);
+        process.exit(1);
+    }
+    if (!collection && command !== '--help') {
+        console.error(`Error: No collection specified for '${command}' command.\n`);
+        console.log(USAGE);
+        process.exit(1);
+    }
+    try {
+        switch (command) {
+            case 'list': {
+                const records = await db.list(collection);
+                console.log(JSON.stringify(records, null, 2));
+                break;
+            }
+            case 'get': {
+                const id = rest[0];
+                if (!id) {
+                    console.error("Error: 'get' command requires an <id> argument.");
+                    process.exit(1);
+                }
+                const record = await db.get(collection, id);
+                if (!record) {
+                    console.error(`Record with id '${id}' not found in '${collection}'.`);
+                    process.exit(1);
+                }
+                console.log(JSON.stringify(record, null, 2));
+                break;
+            }
+            case 'create': {
+                const jsonStr = rest.join(' ');
+                if (!jsonStr) {
+                    console.error("Error: 'create' command requires <json-data> argument.");
+                    process.exit(1);
+                }
+                let data;
+                try {
+                    data = JSON.parse(jsonStr);
+                }
+                catch {
+                    console.error(`Error: Invalid JSON data: ${jsonStr}`);
+                    process.exit(1);
+                }
+                const created = await db.create(collection, data);
+                console.log(JSON.stringify(created, null, 2));
+                break;
+            }
+            case 'delete': {
+                const deleteId = rest[0];
+                if (!deleteId) {
+                    console.error("Error: 'delete' command requires an <id> argument.");
+                    process.exit(1);
+                }
+                const removed = await db.delete(collection, deleteId);
+                console.log(JSON.stringify(removed, null, 2));
+                break;
+            }
+            default:
+                console.error(`Error: Unknown command '${command}'.\n`);
+                console.log(USAGE);
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+run();

package/dist/commands.d.ts

@@ -0,0 +1,7 @@
+interface Command {
+    description: string;
+    bootstrap: boolean;
+    run: (args?: string[]) => Promise<void>;
+}
+declare const commands: Record<string, Command>;
+export default commands;

package/dist/commands.js

@@ -0,0 +1,146 @@
+import { fileToDirectory, directoryToFile } from './migrate.js';
+const commands = {
+    'db:migrate-to-directory': {
+        description: 'Migrate DB from single file to directory mode',
+        bootstrap: true,
+        run: async () => {
+            await fileToDirectory();
+            console.log('DB migration to directory mode complete.');
+        }
+    },
+    'db:migrate-to-file': {
+        description: 'Migrate DB from directory mode to single file',
+        bootstrap: true,
+        run: async () => {
+            await directoryToFile();
+            console.log('DB migration to file mode complete.');
+        }
+    },
+    'db:generate-migration': {
+        description: 'Generate a MySQL migration from current model schemas',
+        bootstrap: true,
+        run: async (args) => {
+            const description = args?.join(' ') || 'migration';
+            const { generateMigration } = await import('./mysql/migration-generator.js');
+            const result = await generateMigration(description);
+            if (result) {
+                console.log(`Migration created: ${result.filename}`);
+            }
+            else {
+                console.log('No schema changes detected. No migration generated.');
+            }
+        }
+    },
+    'db:migrate': {
+        description: 'Apply pending MySQL migrations',
+        bootstrap: true,
+        run: async () => {
+            const config = (await import('stonyx/config')).default;
+            const mysqlConfig = config.orm.mysql;
+            if (!mysqlConfig) {
+                console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
+                process.exit(1);
+            }
+            const { getPool, closePool } = await import('./mysql/connection.js');
+            const { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles, applyMigration, parseMigrationFile } = await import('./mysql/migration-runner.js');
+            const { readFile } = await import('@stonyx/utils/file');
+            const path = await import('path');
+            const pool = await getPool(mysqlConfig);
+            const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir);
+            try {
+                await ensureMigrationsTable(pool, mysqlConfig.migrationsTable);
+                const applied = await getAppliedMigrations(pool, mysqlConfig.migrationsTable);
+                const files = await getMigrationFiles(migrationsPath);
+                const pending = files.filter((f) => !applied.includes(f));
+                if (pending.length === 0) {
+                    console.log('No pending migrations.');
+                    return;
+                }
+                console.log(`Applying ${pending.length} migration(s)...`);
+                for (const filename of pending) {
+                    const content = await readFile(path.join(migrationsPath, filename));
+                    const { up } = parseMigrationFile(content);
+                    await applyMigration(pool, filename, up, mysqlConfig.migrationsTable);
+                    console.log(`  Applied: ${filename}`);
+                }
+                console.log('All migrations applied.');
+            }
+            finally {
+                await closePool();
+            }
+        }
+    },
+    'db:migrate:rollback': {
+        description: 'Rollback the most recent MySQL migration',
+        bootstrap: true,
+        run: async () => {
+            const config = (await import('stonyx/config')).default;
+            const mysqlConfig = config.orm.mysql;
+            if (!mysqlConfig) {
+                console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
+                process.exit(1);
+            }
+            const { getPool, closePool } = await import('./mysql/connection.js');
+            const { ensureMigrationsTable, getAppliedMigrations, rollbackMigration, parseMigrationFile } = await import('./mysql/migration-runner.js');
+            const { readFile } = await import('@stonyx/utils/file');
+            const path = await import('path');
+            const pool = await getPool(mysqlConfig);
+            const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir);
+            try {
+                await ensureMigrationsTable(pool, mysqlConfig.migrationsTable);
+                const applied = await getAppliedMigrations(pool, mysqlConfig.migrationsTable);
+                if (applied.length === 0) {
+                    console.log('No migrations to rollback.');
+                    return;
+                }
+                const lastFilename = applied[applied.length - 1];
+                const content = await readFile(path.join(migrationsPath, lastFilename));
+                const { down } = parseMigrationFile(content);
+                if (!down) {
+                    console.error(`No DOWN section found in ${lastFilename}. Cannot rollback.`);
+                    process.exit(1);
+                }
+                await rollbackMigration(pool, lastFilename, down, mysqlConfig.migrationsTable);
+                console.log(`Rolled back: ${lastFilename}`);
+            }
+            finally {
+                await closePool();
+            }
+        }
+    },
+    'db:migrate:status': {
+        description: 'Show status of MySQL migrations',
+        bootstrap: true,
+        run: async () => {
+            const config = (await import('stonyx/config')).default;
+            const mysqlConfig = config.orm.mysql;
+            if (!mysqlConfig) {
+                console.error('MySQL is not configured. Set MYSQL_HOST to enable MySQL mode.');
+                process.exit(1);
+            }
+            const { getPool, closePool } = await import('./mysql/connection.js');
+            const { ensureMigrationsTable, getAppliedMigrations, getMigrationFiles } = await import('./mysql/migration-runner.js');
+            const path = await import('path');
+            const pool = await getPool(mysqlConfig);
+            const migrationsPath = path.resolve(config.rootPath, mysqlConfig.migrationsDir);
+            try {
+                await ensureMigrationsTable(pool, mysqlConfig.migrationsTable);
+                const applied = new Set(await getAppliedMigrations(pool, mysqlConfig.migrationsTable));
+                const files = await getMigrationFiles(migrationsPath);
+                if (files.length === 0) {
+                    console.log('No migration files found.');
+                    return;
+                }
+                console.log('Migration status:');
+                for (const filename of files) {
+                    const status = applied.has(filename) ? 'applied' : 'pending';
+                    console.log(`  [${status}] ${filename}`);
+                }
+            }
+            finally {
+                await closePool();
+            }
+        }
+    },
+};
+export default commands;

package/dist/db.d.ts

@@ -0,0 +1,21 @@
+export declare const dbKey = "__db";
+interface DBRecord {
+    format(): Record<string, unknown>;
+    [key: string]: unknown;
+}
+export default class DB {
+    static instance: DB;
+    record: DBRecord;
+    constructor();
+    getSchema(): Promise<unknown>;
+    getCollectionKeys(): string[];
+    getDirPath(): string;
+    validateMode(): Promise<void>;
+    init(): Promise<void>;
+    create(): Promise<Record<string, unknown>>;
+    save(): Promise<void>;
+    getRecord(): Promise<DBRecord>;
+    getRecordFromFile(): Promise<DBRecord>;
+    getRecordFromDirectory(): Promise<DBRecord>;
+}
+export {};