@zintrust/core 0.1.19 → 0.1.21

package/src/orm/QueryBuilder.js

@@ -3,14 +3,38 @@
  * Build queries without raw SQL
  */
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
-/**
- * Escape SQL identifier
- */
-const escapeIdentifier = (id) => id
-    .split('.')
-    .map((part) => `"${part.replaceAll('"', '""')}"`)
-    .join('.');
+const getIdentifierQuote = (dialect) => {
+    const d = (dialect ?? '').toLowerCase();
+    if (d === 'mysql') {
+        return {
+            open: '`',
+            close: '`',
+            escape: (raw) => raw.replaceAll('`', '``'),
+        };
+    }
+    if (d === 'sqlserver') {
+        return {
+            open: '[',
+            close: ']',
+            escape: (raw) => raw.replaceAll(']', ']]'),
+        };
+    }
+    // sqlite/postgresql/d1/d1-remote: standard SQL double-quote identifiers.
+    return {
+        open: '"',
+        close: '"',
+        escape: (raw) => raw.replaceAll('"', '""'),
+    };
+};
+const escapeIdentifier = (id, dialect) => {
+    const q = getIdentifierQuote(dialect);
+    return id
+        .split('.')
+        .map((part) => `${q.open}${q.escape(part)}${q.close}`)
+        .join('.');
+};
 const SAFE_IDENTIFIER_PATH = /^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*$/;
+const SAFE_IDENTIFIER = /^[A-Za-z_]\w*$/;
 const assertSafeIdentifierPath = (id, label) => {
     const trimmed = id.trim();
     if (trimmed.length === 0) {
@@ -20,6 +44,15 @@ const assertSafeIdentifierPath = (id, label) => {
         throw ErrorFactory.createDatabaseError(`Unsafe SQL identifier for ${label}`);
     }
 };
+const assertSafeIdentifier = (id, label) => {
+    const trimmed = id.trim();
+    if (trimmed.length === 0) {
+        throw ErrorFactory.createDatabaseError(`Empty SQL identifier for ${label}`);
+    }
+    if (!SAFE_IDENTIFIER.test(trimmed)) {
+        throw ErrorFactory.createDatabaseError(`Unsafe SQL identifier for ${label}`);
+    }
+};
 const normalizeOrderDirection = (direction) => {
     if (direction === undefined || direction === null)
         return 'ASC';
@@ -69,27 +102,98 @@ const isNumericLiteral = (value) => {
     // Disallows: 1e3, 1;DROP, 1 as ok
     return /^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value);
 };
+const ALLOWED_AGGREGATES = new Set(['MAX', 'MIN', 'COUNT', 'SUM', 'AVG']);
+const tryParseAggregateSelectExpr = (raw) => {
+    // Aggregate functions: MAX(col) [AS alias]
+    // Capture content greedily to avoid ReDoS from overlapping whitespace patterns (S5852)
+    const agg = /^(MAX|MIN|COUNT|SUM|AVG)\(([^)]+)\)(?: AS (\S+))?$/i.exec(raw);
+    if (agg === null)
+        return null;
+    const fn = agg[1]?.toUpperCase();
+    const arg = (agg[2] ?? '').trim();
+    const alias = (agg[3] ?? '').trim();
+    if (!ALLOWED_AGGREGATES.has(fn))
+        return null;
+    if (arg !== '*') {
+        assertSafeIdentifierPath(arg, 'aggregate argument');
+    }
+    if (alias.length > 0) {
+        assertSafeIdentifier(alias, 'aggregate alias');
+    }
+    return { kind: 'aggregate', fn, arg, alias: alias.length > 0 ? alias : undefined };
+};
+const tryParseColumnAliasSelectExpr = (raw) => {
+    // Column alias: col [AS alias]
+    // Avoid catastrophic backtracking by using a linear-time separator scan.
+    const upperRaw = raw.toUpperCase();
+    const asIndex = upperRaw.indexOf(' AS ');
+    if (asIndex === -1)
+        return null;
+    const asSeparator = { index: asIndex, 0: raw.slice(asIndex, asIndex + 4) };
+    const col = raw.slice(0, asSeparator.index).trim();
+    const alias = raw.slice(asSeparator.index + asSeparator[0].length).trim();
+    // Alias must be a single token (no whitespace).
+    if (col.length === 0 || alias.length === 0 || /\s/.test(alias))
+        return null;
+    assertSafeIdentifierPath(col, 'select column');
+    assertSafeIdentifier(alias, 'select alias');
+    return { kind: 'column', column: col, alias };
+};
+const tryParseSelectExpr = (expr) => {
+    const raw = expr.trim();
+    if (raw.length === 0) {
+        throw ErrorFactory.createDatabaseError('Empty SQL identifier for select column');
+    }
+    if (raw === '*')
+        return { kind: 'all' };
+    if (isNumericLiteral(raw))
+        return { kind: 'literal', value: raw };
+    const aggregate = tryParseAggregateSelectExpr(raw);
+    if (aggregate !== null)
+        return aggregate;
+    const aliased = tryParseColumnAliasSelectExpr(raw);
+    if (aliased !== null)
+        return aliased;
+    // Plain identifier path
+    assertSafeIdentifierPath(raw, 'select column');
+    return { kind: 'column', column: raw };
+};
 /**
  * Build SELECT clause
  */
-const buildSelectClause = (columns) => columns
-    .map((c) => {
-    if (c === '*')
-        return c;
-    if (isNumericLiteral(c))
-        return c;
-    assertSafeIdentifierPath(c, 'select column');
-    return escapeIdentifier(c);
-})
-    .join(', ');
-const compileWhere = (conditions) => {
+const formatSelectExpr = (parsed, dialect) => {
+    if (parsed.kind === 'all')
+        return '*';
+    if (parsed.kind === 'literal')
+        return parsed.value;
+    if (parsed.kind === 'aggregate') {
+        const argSql = parsed.arg === '*' ? '*' : escapeIdentifier(parsed.arg, dialect);
+        const base = `${parsed.fn}(${argSql})`;
+        const alias = typeof parsed.alias === 'string' && parsed.alias.length > 0 ? parsed.alias : null;
+        return alias === null ? base : `${base} AS ${escapeIdentifier(alias, dialect)}`;
+    }
+    const base = escapeIdentifier(parsed.column, dialect);
+    const alias = typeof parsed.alias === 'string' && parsed.alias.length > 0 ? parsed.alias : null;
+    return alias === null ? base : `${base} AS ${escapeIdentifier(alias, dialect)}`;
+};
+const buildSelectClause = (columns, dialect) => {
+    const out = [];
+    for (const c of columns) {
+        const parsed = tryParseSelectExpr(String(c));
+        if (parsed === null)
+            continue;
+        out.push(formatSelectExpr(parsed, dialect));
+    }
+    return out.join(', ');
+};
+const compileWhere = (conditions, dialect) => {
     if (conditions.length === 0)
         return { sql: '', parameters: [] };
     const parameters = [];
     const clauses = conditions.map((clause) => {
         assertSafeIdentifierPath(clause.column, 'where column');
         const operator = assertSafeOperator(clause.operator);
-        const columnSql = escapeIdentifier(clause.column);
+        const columnSql = escapeIdentifier(clause.column, dialect);
         if (operator === 'IN' || operator === 'NOT IN') {
             if (!Array.isArray(clause.value) || clause.value.length === 0) {
                 throw ErrorFactory.createDatabaseError('IN operator requires a non-empty array');
@@ -142,17 +246,20 @@ const getEffectiveWhereConditions = (state) => {
 /**
  * Build ORDER BY clause
  */
-const buildOrderByClause = (orderBy) => {
-    if (!orderBy)
+const buildOrderByClause = (orderByClauses, dialect) => {
+    if (orderByClauses.length === 0)
         return '';
-    const col = orderBy.column.trim();
-    let columnSql = col;
-    if (!isNumericLiteral(col)) {
-        assertSafeIdentifierPath(col, 'order by column');
-        columnSql = escapeIdentifier(col);
-    }
-    const dir = normalizeOrderDirection(orderBy.direction);
-    return ` ORDER BY ${columnSql} ${dir}`;
+    const parts = orderByClauses.map((orderBy) => {
+        const col = orderBy.column.trim();
+        let columnSql = col;
+        if (!isNumericLiteral(col)) {
+            assertSafeIdentifierPath(col, 'order by column');
+            columnSql = escapeIdentifier(col, dialect);
+        }
+        const dir = normalizeOrderDirection(orderBy.direction);
+        return `${columnSql} ${dir}`;
+    });
+    return ` ORDER BY ${parts.join(', ')}`;
 };
 /**
  * Build LIMIT and OFFSET clause
@@ -173,10 +280,10 @@ const buildSelectQuery = (state) => {
     if (state.tableName.length > 0) {
         assertSafeIdentifierPath(state.tableName, 'table name');
     }
-    const columns = buildSelectClause(state.selectColumns);
-    const fromClause = state.tableName.length > 0 ? ` FROM ${escapeIdentifier(state.tableName)}` : '';
-    const where = compileWhere(getEffectiveWhereConditions(state));
-    const sql = `SELECT ${columns}${fromClause}${where.sql}${buildOrderByClause(state.orderByClause)}${buildLimitOffsetClause(state.limitValue, state.offsetValue)}`;
+    const columns = buildSelectClause(state.selectColumns, state.dialect);
+    const fromClause = state.tableName.length > 0 ? ` FROM ${escapeIdentifier(state.tableName, state.dialect)}` : '';
+    const where = compileWhere(getEffectiveWhereConditions(state), state.dialect);
+    const sql = `SELECT ${columns}${fromClause}${where.sql}${buildOrderByClause(state.orderByClauses, state.dialect)}${buildLimitOffsetClause(state.limitValue, state.offsetValue)}`;
     return { sql, parameters: where.parameters };
 };
 const applyWhereCondition = (state, column, operator, value) => {
@@ -204,7 +311,7 @@ const applyOrderByClause = (state, column, direction) => {
         assertSafeIdentifierPath(col, 'order by column');
     }
     const dir = normalizeOrderDirection(direction);
-    state.orderByClause = { column: col, direction: dir };
+    state.orderByClauses.push({ column: col, direction: dir });
 };
 const applyLimit = (state, count) => {
     assertSafeLimitOffset(count, 'LIMIT');
@@ -224,6 +331,64 @@ async function executeFirst(builder, db) {
     const results = (await db.query(builder.toSQL(), builder.getParameters(), builder.isReadOperation()));
     return results[0] ?? null;
 }
+async function executeFirstOrFail(builder, db, message) {
+    const result = await executeFirst(builder, db);
+    if (result === null)
+        throw ErrorFactory.createNotFoundError(message ?? 'Resource not found');
+    return result;
+}
+const compileInsert = (tableName, values, dialect) => {
+    const items = Array.isArray(values) ? values : [values];
+    if (items.length === 0) {
+        throw ErrorFactory.createDatabaseError('INSERT requires at least one column');
+    }
+    // Use keys from the first item
+    const keys = Object.keys(items[0] ?? {});
+    if (keys.length === 0) {
+        throw ErrorFactory.createDatabaseError('INSERT requires at least one column');
+    }
+    assertSafeIdentifierPath(tableName, 'table name');
+    for (const key of keys)
+        assertSafeIdentifier(key, 'insert column');
+    const colsSql = keys.map((k) => escapeIdentifier(k, dialect)).join(', ');
+    // Single row or multi-row placeholders
+    const rowPlaceholders = `(${keys.map(() => '?').join(', ')})`;
+    const placeholders = items.map(() => rowPlaceholders).join(', ');
+    const parameters = [];
+    for (const item of items) {
+        for (const key of keys) {
+            parameters.push(item[key]);
+        }
+    }
+    const sql = `INSERT INTO ${escapeIdentifier(tableName, dialect)} (${colsSql}) VALUES ${placeholders}`;
+    return { sql, parameters };
+};
+const compileUpdate = (tableName, values, conditions, dialect) => {
+    const keys = Object.keys(values);
+    if (keys.length === 0) {
+        throw ErrorFactory.createDatabaseError('UPDATE requires at least one column');
+    }
+    if (conditions.length === 0) {
+        throw ErrorFactory.createDatabaseError('UPDATE requires at least one WHERE clause');
+    }
+    assertSafeIdentifierPath(tableName, 'table name');
+    for (const key of keys)
+        assertSafeIdentifier(key, 'update column');
+    const setSql = keys.map((k) => `${escapeIdentifier(k, dialect)} = ?`).join(', ');
+    const setParams = keys.map((k) => values[k]);
+    const where = compileWhere(conditions, dialect);
+    const sql = `UPDATE ${escapeIdentifier(tableName, dialect)} SET ${setSql}${where.sql}`;
+    return { sql, parameters: [...setParams, ...where.parameters] };
+};
+const compileDelete = (tableName, conditions, dialect) => {
+    if (conditions.length === 0) {
+        throw ErrorFactory.createDatabaseError('DELETE requires at least one WHERE clause');
+    }
+    assertSafeIdentifierPath(tableName, 'table name');
+    const where = compileWhere(conditions, dialect);
+    const sql = `DELETE FROM ${escapeIdentifier(tableName, dialect)}${where.sql}`;
+    return { sql, parameters: where.parameters };
+};
 /**
  * Execute query and return all results
  */
@@ -235,75 +400,214 @@ async function executeGet(builder, db) {
 /**
  * Create the builder object
  */
-function createBuilder(state, db) {
-    const builder = {
-        select: (...columns) => {
-            state.selectColumns = columns.length > 0 ? columns : ['*'];
-            return builder;
-        },
-        where: (column, operator, value) => {
-            applyWhereCondition(state, column, operator, value);
-            return builder;
-        },
-        andWhere: (column, operator, value) => builder.where(column, operator, value),
-        orWhere: (column, operator, value) => builder.where(column, operator, value),
-        withTrashed: () => {
-            if (state.softDelete === undefined) {
-                state.softDelete = { column: 'deleted_at', mode: 'include' };
-            }
-            else {
-                state.softDelete.mode = 'include';
-            }
-            return builder;
-        },
-        onlyTrashed: () => {
-            if (state.softDelete === undefined) {
-                state.softDelete = { column: 'deleted_at', mode: 'only' };
-            }
-            else {
-                state.softDelete.mode = 'only';
-            }
-            return builder;
-        },
-        withoutTrashed: () => {
-            if (state.softDelete === undefined) {
-                state.softDelete = { column: 'deleted_at', mode: 'exclude' };
+function attachSelectMethods(builder, state) {
+    const clearDefaultStar = () => {
+        if (state.selectColumns.length === 1 && state.selectColumns[0] === '*')
+            state.selectColumns = [];
+    };
+    builder.select = (...columns) => {
+        state.selectColumns = columns.length > 0 ? columns : ['*'];
+        return builder;
+    };
+    builder.selectAs = (column, alias) => {
+        const col = String(column).trim();
+        const a = String(alias).trim();
+        assertSafeIdentifierPath(col, 'select column');
+        assertSafeIdentifier(a, 'select alias');
+        clearDefaultStar();
+        state.selectColumns.push(`${col} AS ${a}`);
+        return builder;
+    };
+    builder.max = (column, alias = 'max') => {
+        const col = String(column).trim();
+        const a = String(alias).trim();
+        assertSafeIdentifierPath(col, 'aggregate argument');
+        assertSafeIdentifier(a, 'aggregate alias');
+        clearDefaultStar();
+        state.selectColumns.push(`MAX(${col}) AS ${a}`);
+        return builder;
+    };
+}
+function attachWhereMethods(builder, state) {
+    builder.where = (column, operator, value) => {
+        applyWhereCondition(state, column, operator, value);
+        return builder;
+    };
+    builder.andWhere = (column, operator, value) => builder.where(column, operator, value);
+    builder.orWhere = (column, operator, value) => builder.where(column, operator, value);
+    builder.whereIn = (column, values) => {
+        builder.where(column, 'IN', values);
+        return builder;
+    };
+    builder.whereNotIn = (column, values) => {
+        builder.where(column, 'NOT IN', values);
+        return builder;
+    };
+}
+function attachSoftDeleteMethods(builder, state) {
+    builder.withTrashed = () => {
+        if (state.softDelete === undefined) {
+            state.softDelete = { column: 'deleted_at', mode: 'include' };
+        }
+        else {
+            state.softDelete.mode = 'include';
+        }
+        return builder;
+    };
+    builder.onlyTrashed = () => {
+        if (state.softDelete === undefined) {
+            state.softDelete = { column: 'deleted_at', mode: 'only' };
+        }
+        else {
+            state.softDelete.mode = 'only';
+        }
+        return builder;
+    };
+    builder.withoutTrashed = () => {
+        if (state.softDelete === undefined) {
+            state.softDelete = { column: 'deleted_at', mode: 'exclude' };
+        }
+        else {
+            state.softDelete.mode = 'exclude';
+        }
+        return builder;
+    };
+}
+function attachJoinOrderPagingMethods(builder, state) {
+    builder.join = (tableJoin, on) => {
+        state.joins.push({ table: tableJoin, on });
+        return builder;
+    };
+    builder.leftJoin = (tableJoin, on) => builder.join(tableJoin, on);
+    builder.orderBy = (column, direction = 'ASC') => {
+        applyOrderByClause(state, column, direction);
+        return builder;
+    };
+    builder.limit = (count) => {
+        applyLimit(state, count);
+        return builder;
+    };
+    builder.offset = (count) => {
+        applyOffset(state, count);
+        return builder;
+    };
+}
+function attachIntrospectionMethods(builder, state) {
+    builder.getWhereClauses = () => state.whereConditions;
+    builder.getSelectColumns = () => state.selectColumns;
+    builder.getTable = () => state.tableName;
+    builder.getLimit = () => state.limitValue;
+    builder.getOffset = () => state.offsetValue;
+    builder.getOrderBy = () => state.orderByClauses.at(-1);
+    builder.getJoins = () => state.joins;
+    builder.isReadOperation = () => true;
+    builder.toSQL = () => buildSelectQuery(state).sql;
+    builder.getParameters = () => buildSelectQuery(state).parameters;
+    // Internal method for eager loading distribution
+    builder.getEagerLoads = () => state.eagerLoads;
+}
+function attachReadExecutionMethods(builder, db) {
+    builder.first = async () => executeFirst(builder, db);
+    builder.firstOrFail = async (message) => executeFirstOrFail(builder, db, message);
+    builder.get = async () => executeGet(builder, db);
+    // raw just returns results without any hydration logic in callers
+    builder.raw = async () => executeGet(builder, db);
+}
+function attachRelationshipMethods(builder, state) {
+    builder.with = (relation) => {
+        state.eagerLoads.push(relation);
+        return builder;
+    };
+    builder.load = async (models, relation) => {
+        if (models.length === 0)
+            return;
+        // We assume the first model can give us the relationship definition
+        const firstModel = models[0];
+        if (typeof firstModel[relation] !== 'function')
+            return;
+        const rel = firstModel[relation]();
+        if (rel === null || rel === undefined)
+            return;
+        const related = rel.related;
+        if (related === null || related === undefined)
+            return;
+        const foreignKey = rel.foreignKey;
+        const localKey = rel.localKey;
+        const ids = models
+            .map((m) => m.getAttribute(localKey))
+            .filter((id) => id !== null && id !== undefined);
+        if (ids.length === 0)
+            return;
+        // Call query on the related model
+        const relatedModel = rel.related;
+        if (typeof relatedModel.query !== 'function')
+            return;
+        const relatedResults = await relatedModel.query().whereIn(foreignKey, ids).get();
+        // Map results back to models
+        for (const model of models) {
+            const modelId = model.getAttribute(localKey);
+            if (rel.type === 'hasMany' || rel.type === 'belongsToMany') {
+                const filtered = relatedResults.filter((r) => r.getAttribute(foreignKey) === modelId);
+                model.setRelation(relation, filtered);
             }
             else {
-                state.softDelete.mode = 'exclude';
+                const found = relatedResults.find((r) => r.getAttribute(foreignKey) === modelId);
+                model.setRelation(relation, found ?? null);
             }
-            return builder;
-        },
-        join: (tableJoin, on) => {
-            state.joins.push({ table: tableJoin, on });
-            return builder;
-        },
-        leftJoin: (tableJoin, on) => builder.join(tableJoin, on),
-        orderBy: (column, direction = 'ASC') => {
-            applyOrderByClause(state, column, direction);
-            return builder;
-        },
-        limit: (count) => {
-            applyLimit(state, count);
-            return builder;
-        },
-        offset: (count) => {
-            applyOffset(state, count);
-            return builder;
-        },
-        getWhereClauses: () => state.whereConditions,
-        getSelectColumns: () => state.selectColumns,
-        getTable: () => state.tableName,
-        getLimit: () => state.limitValue,
-        getOffset: () => state.offsetValue,
-        getOrderBy: () => state.orderByClause,
-        getJoins: () => state.joins,
-        isReadOperation: () => true,
-        toSQL: () => buildSelectQuery(state).sql,
-        getParameters: () => buildSelectQuery(state).parameters,
-        first: async () => executeFirst(builder, db),
-        get: async () => executeGet(builder, db),
+        }
     };
+}
+function attachWriteMethods(builder, state, db) {
+    const ensureDb = () => {
+        if (!db)
+            throw ErrorFactory.createDatabaseError('Database instance not provided to QueryBuilder');
+        return db;
+    };
+    builder.insert = async (values) => {
+        const currentDb = ensureDb();
+        const tableName = state.tableName.trim();
+        if (tableName.length === 0)
+            throw ErrorFactory.createDatabaseError('INSERT requires a table name');
+        const compiled = compileInsert(tableName, values, state.dialect);
+        const items = Array.isArray(values) ? values : [values];
+        const result = await currentDb.execute(compiled.sql, compiled.parameters, false);
+        // Return InsertResult with metadata
+        // Note: lastInsertId typically only available for single-row inserts in most databases
+        // For multi-row inserts, use the insertedRecords array
+        return {
+            id: result.lastInsertId ??
+                (items.length === 1 ? (items[0]?.['id'] ?? null) : null),
+            affectedRows: result.rowCount,
+            insertedRecords: items,
+        };
+    };
+    builder.update = async (values) => {
+        const currentDb = ensureDb();
+        const tableName = state.tableName.trim();
+        if (tableName.length === 0)
+            throw ErrorFactory.createDatabaseError('UPDATE requires a table name');
+        const compiled = compileUpdate(tableName, values, state.whereConditions, state.dialect);
+        await currentDb.query(compiled.sql, compiled.parameters, false);
+    };
+    builder.delete = async () => {
+        const currentDb = ensureDb();
+        const tableName = state.tableName.trim();
+        if (tableName.length === 0)
+            throw ErrorFactory.createDatabaseError('DELETE requires a table name');
+        const compiled = compileDelete(tableName, state.whereConditions, state.dialect);
+        await currentDb.query(compiled.sql, compiled.parameters, false);
+    };
+}
+function createBuilder(state, db) {
+    const builder = {};
+    attachSelectMethods(builder, state);
+    attachWhereMethods(builder, state);
+    attachSoftDeleteMethods(builder, state);
+    attachJoinOrderPagingMethods(builder, state);
+    attachIntrospectionMethods(builder, state);
+    attachReadExecutionMethods(builder, db);
+    attachRelationshipMethods(builder, state);
+    attachWriteMethods(builder, state, db);
     return builder;
 }
 /**
@@ -327,7 +631,10 @@ export const QueryBuilder = Object.freeze({
             tableName,
             whereConditions: [],
             selectColumns: ['*'],
+            orderByClauses: [],
             joins: [],
+            eagerLoads: [],
+            dialect: typeof database?.getType === 'function' ? database.getType() : undefined,
         };
         if (options.softDeleteColumn !== undefined && options.softDeleteColumn.trim().length > 0) {
             state.softDelete = {

package/src/orm/Relationships.d.ts

@@ -2,7 +2,7 @@
  * Relationship Types
  * Define how models relate to each other
  */
-import { IModel, Model, ModelStatic } from './Model';
+import type { IModel, Model, ModelStatic } from './Model';
 export type RelationshipType = 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
 export interface Relation {
     type: RelationshipType;
@@ -13,6 +13,12 @@ export interface Relation {
 }
 export interface IRelationship {
     get(instance: IModel): Promise<unknown>;
+    type: RelationshipType;
+    related: ModelStatic;
+    foreignKey: string;
+    localKey: string;
+    throughTable?: string;
+    relatedKey?: string;
 }
 /**
  * HasOne Relationship

package/src/orm/Relationships.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Relationships.d.ts","sourceRoot":"","sources":["../../../src/orm/Relationships.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,eAAe,CAAC;AAEpF,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,OAAO,KAAK,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACzC;AAUD;;;;;GAKG;AACH,eAAO,MAAM,MAAM;yBACI,WAAW,cAAc,MAAM,YAAY,MAAM,GAAG,aAAa;EAUtF,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,OAAO;yBACG,WAAW,cAAc,MAAM,YAAY,MAAM,GAAG,aAAa;EAUtF,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,SAAS;yBACC,WAAW,cAAc,MAAM,YAAY,MAAM,GAAG,aAAa;EAUtF,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa;yBAER,WAAW,gBACX,MAAM,cACR,MAAM,cACN,MAAM,GACjB,aAAa;EA8BhB,CAAC"}
+{"version":3,"file":"Relationships.d.ts","sourceRoot":"","sources":["../../../src/orm/Relationships.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,eAAe,CAAC;AAEpF,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,OAAO,KAAK,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACxC,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAUD;;;;;GAKG;AACH,eAAO,MAAM,MAAM;yBACI,WAAW,cAAc,MAAM,YAAY,MAAM,GAAG,aAAa;EActF,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,OAAO;yBACG,WAAW,cAAc,MAAM,YAAY,MAAM,GAAG,aAAa;EActF,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,SAAS;yBACC,WAAW,cAAc,MAAM,YAAY,MAAM,GAAG,aAAa;EActF,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa;yBAER,WAAW,gBACX,MAAM,cACR,MAAM,cACN,MAAM,GACjB,aAAa;EAoChB,CAAC"}

package/src/orm/Relationships.js

@@ -18,6 +18,10 @@ const getRelatedTableName = (relatedModel) => {
 export const HasOne = Object.freeze({
     create(relatedModel, foreignKey, localKey) {
         return {
+            type: 'hasOne',
+            related: relatedModel,
+            foreignKey,
+            localKey,
             async get(instance) {
                 const value = instance.getAttribute(localKey);
                 if (value === undefined || value === null || value === '')
@@ -36,6 +40,10 @@ export const HasOne = Object.freeze({
 export const HasMany = Object.freeze({
     create(relatedModel, foreignKey, localKey) {
         return {
+            type: 'hasMany',
+            related: relatedModel,
+            foreignKey,
+            localKey,
             async get(instance) {
                 const value = instance.getAttribute(localKey);
                 if (value === undefined || value === null || value === '')
@@ -54,6 +62,10 @@ export const HasMany = Object.freeze({
 export const BelongsTo = Object.freeze({
     create(relatedModel, foreignKey, localKey) {
         return {
+            type: 'belongsTo',
+            related: relatedModel,
+            foreignKey,
+            localKey,
             async get(instance) {
                 const value = instance.getAttribute(foreignKey);
                 if (value === undefined || value === null || value === '')
@@ -81,6 +93,12 @@ export const BelongsToMany = Object.freeze({
                 relatedKey !== '');
         };
         return {
+            type: 'belongsToMany',
+            related: relatedModel,
+            throughTable,
+            foreignKey,
+            relatedKey,
+            localKey: 'id',
             async get(instance) {
                 if (!isValidInstance(instance)) {
                     return [];

package/src/orm/SchemaCompiler.d.ts

@@ -0,0 +1,9 @@
+import type { IDatabase } from './Database';
+import type { ISchema } from './Schema';
+export declare const SchemaCompiler: Readonly<{
+    createTable(db: IDatabase, schema: ISchema, opts?: {
+        ifNotExists?: boolean;
+    }): Promise<void>;
+    dropTable(db: IDatabase, table: string): Promise<void>;
+}>;
+//# sourceMappingURL=SchemaCompiler.d.ts.map

package/src/orm/SchemaCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaCompiler.d.ts","sourceRoot":"","sources":["../../../src/orm/SchemaCompiler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAoB,OAAO,EAAE,MAAM,aAAa,CAAC;AA4I7D,eAAO,MAAM,cAAc;oBAEnB,SAAS,UACL,OAAO,SACR;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,OAAO,CAAC,IAAI,CAAC;kBAMI,SAAS,SAAS,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EAM5D,CAAC"}