@stonyx/orm 0.2.1-beta.9 → 0.2.1-beta.90

package/dist/mysql/schema-introspector.js

@@ -0,0 +1,291 @@
+import Orm from '@stonyx/orm';
+import { getMysqlType } from './type-map.js';
+import { camelCaseToKebabCase } from '@stonyx/utils/string';
+import { getPluralName } from '../plural-registry.js';
+import { dbKey } from '../db.js';
+import { AggregateProperty } from '../aggregates.js';
+import ModelProperty from '../model-property.js';
+function getRelationshipInfo(property) {
+    if (typeof property !== 'function')
+        return null;
+    const relType = property.__relationshipType;
+    const modelName = property.__relatedModelName || null;
+    if (relType === 'belongsTo')
+        return { type: 'belongsTo', modelName };
+    if (relType === 'hasMany')
+        return { type: 'hasMany', modelName };
+    return null;
+}
+function sanitizeTableName(name) {
+    return name.replace(/[-/]/g, '_');
+}
+export function introspectModels() {
+    const { models } = Orm.instance;
+    const schemas = {};
+    for (const [modelKey, modelClass] of Object.entries(models)) {
+        const name = camelCaseToKebabCase(modelKey.slice(0, -5));
+        if (name === dbKey)
+            continue;
+        const model = new modelClass(modelKey);
+        const columns = {};
+        const foreignKeys = {};
+        const relationships = { belongsTo: {}, hasMany: {} };
+        let idType = 'number';
+        const transforms = Orm.instance.transforms;
+        for (const [key, property] of Object.entries(model)) {
+            if (key.startsWith('__'))
+                continue;
+            const relInfo = getRelationshipInfo(property);
+            if (relInfo?.type === 'belongsTo') {
+                relationships.belongsTo[key] = relInfo.modelName;
+            }
+            else if (relInfo?.type === 'hasMany') {
+                relationships.hasMany[key] = relInfo.modelName;
+            }
+            else if (property instanceof ModelProperty) {
+                if (key === 'id') {
+                    idType = property.type;
+                }
+                else {
+                    columns[key] = getMysqlType(property.type, transforms[property.type]);
+                }
+            }
+        }
+        // Build foreign keys from belongsTo relationships
+        for (const [relName, targetModelName] of Object.entries(relationships.belongsTo)) {
+            if (!targetModelName)
+                continue;
+            const fkColumn = `${relName}_id`;
+            foreignKeys[fkColumn] = {
+                references: sanitizeTableName(getPluralName(targetModelName)),
+                column: 'id',
+            };
+        }
+        schemas[name] = {
+            table: sanitizeTableName(getPluralName(name)),
+            idType,
+            columns,
+            foreignKeys,
+            relationships,
+            memory: modelClass.memory === true,
+        };
+    }
+    return schemas;
+}
+export function buildTableDDL(name, schema, allSchemas = {}) {
+    const { idType, columns, foreignKeys } = schema;
+    const table = sanitizeTableName(schema.table);
+    const lines = [];
+    // Primary key
+    if (idType === 'string') {
+        lines.push('  `id` VARCHAR(255) PRIMARY KEY');
+    }
+    else {
+        lines.push('  `id` INT AUTO_INCREMENT PRIMARY KEY');
+    }
+    // Attribute columns
+    for (const [col, mysqlType] of Object.entries(columns)) {
+        lines.push(`  \`${col}\` ${mysqlType}`);
+    }
+    // Foreign key columns
+    for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
+        const refIdType = getReferencedIdType(fkDef.references, allSchemas);
+        lines.push(`  \`${fkCol}\` ${refIdType}`);
+    }
+    // Timestamps
+    lines.push('  `created_at` DATETIME DEFAULT CURRENT_TIMESTAMP');
+    lines.push('  `updated_at` DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP');
+    // Foreign key constraints
+    for (const [fkCol, fkDef] of Object.entries(foreignKeys)) {
+        const refTable = sanitizeTableName(fkDef.references);
+        lines.push(`  FOREIGN KEY (\`${fkCol}\`) REFERENCES \`${refTable}\`(\`${fkDef.column}\`) ON DELETE SET NULL`);
+    }
+    return `CREATE TABLE IF NOT EXISTS \`${table}\` (\n${lines.join(',\n')}\n)`;
+}
+function getReferencedIdType(tableName, allSchemas) {
+    // Look up the referenced table's PK type from schemas
+    for (const schema of Object.values(allSchemas)) {
+        if (schema.table === tableName) {
+            return schema.idType === 'string' ? 'VARCHAR(255)' : 'INT';
+        }
+    }
+    // Default to INT if referenced table not found in schemas
+    return 'INT';
+}
+export function getTopologicalOrder(schemas) {
+    const visited = new Set();
+    const order = [];
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        visited.add(name);
+        const schema = schemas[name];
+        if (!schema)
+            return;
+        // Visit dependencies (belongsTo targets) first
+        for (const targetModelName of Object.values(schema.relationships.belongsTo)) {
+            if (targetModelName)
+                visit(targetModelName);
+        }
+        order.push(name);
+    }
+    for (const name of Object.keys(schemas)) {
+        visit(name);
+    }
+    return order;
+}
+export function introspectViews() {
+    const orm = Orm.instance;
+    if (!orm.views)
+        return {};
+    const schemas = {};
+    for (const [viewKey, viewClass] of Object.entries(orm.views)) {
+        const name = camelCaseToKebabCase(viewKey.slice(0, -4)); // Remove 'View' suffix
+        const source = viewClass.source;
+        if (!source)
+            continue;
+        const model = new viewClass(name);
+        const columns = {};
+        const foreignKeys = {};
+        const aggregates = {};
+        const relationships = { belongsTo: {}, hasMany: {} };
+        for (const [key, property] of Object.entries(model)) {
+            if (key.startsWith('__'))
+                continue;
+            if (key === 'id')
+                continue;
+            if (property instanceof AggregateProperty) {
+                aggregates[key] = property;
+                continue;
+            }
+            const relInfo = getRelationshipInfo(property);
+            if (relInfo?.type === 'belongsTo') {
+                relationships.belongsTo[key] = relInfo.modelName;
+                if (relInfo.modelName) {
+                    const fkColumn = `${key}_id`;
+                    foreignKeys[fkColumn] = {
+                        references: sanitizeTableName(getPluralName(relInfo.modelName)),
+                        column: 'id',
+                    };
+                }
+            }
+            else if (relInfo?.type === 'hasMany') {
+                relationships.hasMany[key] = relInfo.modelName;
+            }
+            else if (property instanceof ModelProperty) {
+                const transforms = orm.transforms;
+                columns[key] = getMysqlType(property.type, transforms[property.type]);
+            }
+        }
+        schemas[name] = {
+            viewName: sanitizeTableName(getPluralName(name)),
+            source,
+            groupBy: viewClass.groupBy || undefined,
+            columns,
+            foreignKeys,
+            aggregates,
+            relationships,
+            isView: true,
+            memory: false,
+        };
+    }
+    return schemas;
+}
+export function buildViewDDL(name, viewSchema, modelSchemas = {}) {
+    if (!viewSchema.source) {
+        throw new Error(`View '${name}' must define a source model`);
+    }
+    const sourceModelName = viewSchema.source;
+    const sourceSchema = modelSchemas[sourceModelName];
+    const sourceTable = sanitizeTableName(sourceSchema
+        ? sourceSchema.table
+        : getPluralName(sourceModelName));
+    const selectColumns = [];
+    const joins = [];
+    const hasAggregates = Object.keys(viewSchema.aggregates || {}).length > 0;
+    const groupByField = viewSchema.groupBy;
+    // ID column: groupBy field or source table PK
+    if (groupByField) {
+        selectColumns.push(`\`${sourceTable}\`.\`${groupByField}\` AS \`id\``);
+    }
+    else {
+        selectColumns.push(`\`${sourceTable}\`.\`id\` AS \`id\``);
+    }
+    // Aggregate columns
+    for (const [key, aggProp] of Object.entries(viewSchema.aggregates || {})) {
+        if (aggProp.relationship === undefined) {
+            // Field-level aggregate (groupBy views)
+            if (aggProp.aggregateType === 'count') {
+                selectColumns.push(`COUNT(*) AS \`${key}\``);
+            }
+            else {
+                selectColumns.push(`${aggProp.mysqlFunction}(\`${sourceTable}\`.\`${aggProp.field}\`) AS \`${key}\``);
+            }
+        }
+        else {
+            // Relationship aggregate
+            const relName = aggProp.relationship;
+            const relTable = sanitizeTableName(getPluralName(relName));
+            if (aggProp.aggregateType === 'count') {
+                selectColumns.push(`${aggProp.mysqlFunction}(\`${relTable}\`.\`id\`) AS \`${key}\``);
+            }
+            else {
+                const field = aggProp.field;
+                selectColumns.push(`${aggProp.mysqlFunction}(\`${relTable}\`.\`${field}\`) AS \`${key}\``);
+            }
+            // Add LEFT JOIN for the relationship if not already added
+            const joinKey = `${relTable}`;
+            if (!joins.find(j => j.table === joinKey)) {
+                const fkColumn = `${sourceModelName}_id`;
+                joins.push({
+                    table: relTable,
+                    condition: `\`${relTable}\`.\`${fkColumn}\` = \`${sourceTable}\`.\`id\``
+                });
+            }
+        }
+    }
+    // Regular columns (from resolve map string paths or direct attr fields)
+    for (const [key] of Object.entries(viewSchema.columns || {})) {
+        selectColumns.push(`\`${sourceTable}\`.\`${key}\` AS \`${key}\``);
+    }
+    // Build JOIN clauses
+    const joinClauses = joins.map(j => `LEFT JOIN \`${j.table}\` ON ${j.condition}`).join('\n  ');
+    // Build GROUP BY
+    let groupBy = '';
+    if (groupByField) {
+        groupBy = `\nGROUP BY \`${sourceTable}\`.\`${groupByField}\``;
+    }
+    else if (hasAggregates) {
+        groupBy = `\nGROUP BY \`${sourceTable}\`.\`id\``;
+    }
+    const viewName = sanitizeTableName(viewSchema.viewName);
+    const sql = `CREATE OR REPLACE VIEW \`${viewName}\` AS\nSELECT\n  ${selectColumns.join(',\n  ')}\nFROM \`${sourceTable}\`${joinClauses ? '\n  ' + joinClauses : ''}${groupBy}`;
+    return sql;
+}
+export function viewSchemasToSnapshot(viewSchemas) {
+    const snapshot = {};
+    for (const [name, schema] of Object.entries(viewSchemas)) {
+        snapshot[name] = {
+            viewName: schema.viewName,
+            source: schema.source,
+            ...(schema.groupBy ? { groupBy: schema.groupBy } : {}),
+            columns: { ...schema.columns },
+            foreignKeys: { ...schema.foreignKeys },
+            isView: true,
+            viewQuery: buildViewDDL(name, schema),
+        };
+    }
+    return snapshot;
+}
+export function schemasToSnapshot(schemas) {
+    const snapshot = {};
+    for (const [name, schema] of Object.entries(schemas)) {
+        snapshot[name] = {
+            table: schema.table,
+            idType: schema.idType,
+            columns: { ...schema.columns },
+            foreignKeys: { ...schema.foreignKeys },
+        };
+    }
+    return snapshot;
+}

package/dist/mysql/type-map.d.ts

@@ -0,0 +1,21 @@
+interface TransformFn {
+    mysqlType?: string;
+    (...args: unknown[]): unknown;
+}
+declare const typeMap: Record<string, string>;
+/**
+ * Resolves a Stonyx ORM attribute type to a MySQL column type.
+ *
+ * For built-in types, returns the mapped MySQL type directly.
+ *
+ * For custom transforms (e.g. an `animal` transform that maps strings to ints):
+ *   - If the transform function exports a `mysqlType` property, that value is used.
+ *     Example: `const transform = (v) => codeMap[v]; transform.mysqlType = 'INT'; export default transform;`
+ *   - Otherwise, defaults to JSON. Values are JSON-stringified on write and
+ *     JSON-parsed on read. This handles primitives and plain objects correctly.
+ *     Class instances will be reduced to plain objects — if a custom transform
+ *     produces class instances, it must declare a `mysqlType` and handle
+ *     serialization itself.
+ */
+export declare function getMysqlType(attrType: string, transformFn?: TransformFn): string;
+export default typeMap;

package/dist/mysql/type-map.js

@@ -0,0 +1,36 @@
+const typeMap = {
+    string: 'VARCHAR(255)',
+    number: 'INT',
+    float: 'FLOAT',
+    boolean: 'TINYINT(1)',
+    date: 'DATETIME',
+    timestamp: 'BIGINT',
+    passthrough: 'TEXT',
+    trim: 'VARCHAR(255)',
+    uppercase: 'VARCHAR(255)',
+    ceil: 'INT',
+    floor: 'INT',
+    round: 'INT',
+};
+/**
+ * Resolves a Stonyx ORM attribute type to a MySQL column type.
+ *
+ * For built-in types, returns the mapped MySQL type directly.
+ *
+ * For custom transforms (e.g. an `animal` transform that maps strings to ints):
+ *   - If the transform function exports a `mysqlType` property, that value is used.
+ *     Example: `const transform = (v) => codeMap[v]; transform.mysqlType = 'INT'; export default transform;`
+ *   - Otherwise, defaults to JSON. Values are JSON-stringified on write and
+ *     JSON-parsed on read. This handles primitives and plain objects correctly.
+ *     Class instances will be reduced to plain objects — if a custom transform
+ *     produces class instances, it must declare a `mysqlType` and handle
+ *     serialization itself.
+ */
+export function getMysqlType(attrType, transformFn) {
+    if (typeMap[attrType])
+        return typeMap[attrType];
+    if (transformFn?.mysqlType)
+        return transformFn.mysqlType;
+    return 'JSON';
+}
+export default typeMap;

package/dist/orm-request.d.ts

@@ -0,0 +1,38 @@
+import { Request } from '@stonyx/rest-server';
+interface OrmRequest$ extends Request {
+    protocol?: string;
+    method: string;
+    params: {
+        [key: string]: string;
+    };
+    body?: {
+        [key: string]: unknown;
+    };
+    query?: {
+        [key: string]: string;
+    };
+    get(header: string): string;
+}
+type AccessMethod = string | boolean | string[] | ((record: unknown) => boolean);
+type HandlerFn = (request: OrmRequest$, state: {
+    [key: string]: unknown;
+}) => unknown | Promise<unknown>;
+export default class OrmRequest extends Request {
+    model: string;
+    access: (request: unknown) => AccessMethod;
+    handlers: {
+        [key: string]: {
+            [key: string]: HandlerFn;
+        };
+    };
+    constructor({ model, access }: {
+        model: string;
+        access: (request: unknown) => AccessMethod;
+    });
+    private _withHooks;
+    private _generateRelationshipRoutes;
+    auth(request: OrmRequest$, state: {
+        [key: string]: unknown;
+    }): number | undefined;
+}
+export {};