@zintrust/core 0.1.21 → 0.1.23

package/src/orm/QueryBuilder.js

@@ -2,6 +2,7 @@
  * QueryBuilder - Type-Safe Query Builder
  * Build queries without raw SQL
  */
+import { createPaginator } from '../database/Paginator.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
 const getIdentifierQuote = (dialect) => {
     const d = (dialect ?? '').toLowerCase();
@@ -286,6 +287,15 @@ const buildSelectQuery = (state) => {
     const sql = `SELECT ${columns}${fromClause}${where.sql}${buildOrderByClause(state.orderByClauses, state.dialect)}${buildLimitOffsetClause(state.limitValue, state.offsetValue)}`;
     return { sql, parameters: where.parameters };
 };
+const buildCountQuery = (state) => {
+    if (state.tableName.length > 0) {
+        assertSafeIdentifierPath(state.tableName, 'table name');
+    }
+    const fromClause = state.tableName.length > 0 ? ` FROM ${escapeIdentifier(state.tableName, state.dialect)}` : '';
+    const where = compileWhere(getEffectiveWhereConditions(state), state.dialect);
+    const sql = `SELECT COUNT(*) AS total${fromClause}${where.sql}`;
+    return { sql, parameters: where.parameters };
+};
 const applyWhereCondition = (state, column, operator, value) => {
     const col = String(column).trim();
     assertSafeIdentifierPath(col, 'where column');
@@ -397,6 +407,40 @@ async function executeGet(builder, db) {
         throw ErrorFactory.createDatabaseError('Database instance not provided to QueryBuilder');
     return (await db.query(builder.toSQL(), builder.getParameters(), builder.isReadOperation()));
 }
+const normalizePaginationValue = (value, label) => {
+    const n = Math.trunc(value);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw ErrorFactory.createValidationError(`${label} must be a positive integer`);
+    }
+    return n;
+};
+async function executePaginate(builder, state, db, page, perPage, options) {
+    if (!db)
+        throw ErrorFactory.createDatabaseError('Database instance not provided to QueryBuilder');
+    const safePage = normalizePaginationValue(page, 'page');
+    const safePerPage = normalizePaginationValue(perPage, 'perPage');
+    const countQuery = buildCountQuery(state);
+    const countRows = (await db.query(countQuery.sql, countQuery.parameters, true));
+    const rawTotal = countRows.at(0)?.['total'];
+    const total = typeof rawTotal === 'bigint' ? Number(rawTotal) : Number(rawTotal ?? 0);
+    const sanitizedTotal = Number.isFinite(total) && total > 0 ? total : 0;
+    const offset = (safePage - 1) * safePerPage;
+    const prevLimit = state.limitValue;
+    const prevOffset = state.offsetValue;
+    state.limitValue = safePerPage;
+    state.offsetValue = offset;
+    const items = await executeGet(builder, db);
+    state.limitValue = prevLimit;
+    state.offsetValue = prevOffset;
+    return createPaginator({
+        items,
+        total: sanitizedTotal,
+        perPage: safePerPage,
+        currentPage: safePage,
+        baseUrl: options?.baseUrl,
+        query: options?.query,
+    });
+}
 /**
  * Create the builder object
  */
@@ -505,57 +549,411 @@ function attachIntrospectionMethods(builder, state) {
     builder.getParameters = () => buildSelectQuery(state).parameters;
     // Internal method for eager loading distribution
     builder.getEagerLoads = () => state.eagerLoads;
+    builder.getEagerLoadConstraints = () => state.eagerLoadConstraints;
+    builder.getEagerLoadCounts = () => state.eagerLoadCounts;
 }
-function attachReadExecutionMethods(builder, db) {
+function attachReadExecutionMethods(builder, state, db) {
     builder.first = async () => executeFirst(builder, db);
     builder.firstOrFail = async (message) => executeFirstOrFail(builder, db, message);
     builder.get = async () => executeGet(builder, db);
+    builder.paginate = async (page, perPage, options) => executePaginate(builder, state, db, page, perPage, options);
     // 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;
+const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+const isKeyValue = (value) => typeof value === 'string' || typeof value === 'number';
+const getModelIds = (models, key) => models.map((model) => model.getAttribute(key)).filter(isKeyValue);
+const applyConstraint = (query, constraint) => {
+    if (typeof constraint === 'function') {
+        return constraint(query) ?? query;
+    }
+    return query;
+};
+/**
+ * Load relationship counts for a collection of models
+ */
+async function loadCounts(models, relation, db) {
+    if (models.length === 0 || !db)
+        return;
+    const firstModel = models[0];
+    if (typeof firstModel[relation] !== 'function')
+        return;
+    const rel = firstModel[relation]();
+    if (rel === null || rel === undefined)
+        return;
+    const relType = rel.type;
+    // Only hasMany and belongsToMany support counts
+    if (relType !== 'hasMany' && relType !== 'belongsToMany') {
+        return;
+    }
+    const foreignKey = rel.foreignKey;
+    const localKey = rel.localKey;
+    const ids = getModelIds(models, localKey);
+    if (ids.length === 0)
+        return;
+    const dialect = typeof db.getType === 'function' ? db.getType() : undefined;
+    const queryCounts = async (sql, params) => {
+        const results = (await db.query(sql, params, true));
+        const map = new Map();
+        for (const row of results) {
+            let count;
+            if (typeof row.count === 'bigint') {
+                count = Number(row.count);
+            }
+            else if (typeof row.count === 'number') {
+                count = row.count;
+            }
+            else {
+                count = Number(row.count ?? 0);
+            }
+            map.set(row.key, count);
+        }
+        return map;
     };
-    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
+    const setCountsOnModels = (countMap) => {
         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);
+            if (isKeyValue(modelId)) {
+                const count = countMap.get(modelId) ?? 0;
+                model.setAttribute(`${relation}_count`, count);
             }
             else {
-                const found = relatedResults.find((r) => r.getAttribute(foreignKey) === modelId);
-                model.setRelation(relation, found ?? null);
+                model.setAttribute(`${relation}_count`, 0);
             }
         }
     };
+    if (relType === 'hasMany') {
+        const relatedModel = rel.related;
+        if (typeof relatedModel?.query !== 'function')
+            return;
+        const tempQuery = relatedModel.query();
+        const relatedTable = tempQuery.getTable();
+        const sql = `SELECT ${escapeIdentifier(foreignKey, dialect)} as key, COUNT(*) as count FROM ${escapeIdentifier(relatedTable, dialect)} WHERE ${escapeIdentifier(foreignKey, dialect)} IN (${ids.map(() => '?').join(',')}) GROUP BY ${escapeIdentifier(foreignKey, dialect)}`;
+        const countMap = await queryCounts(sql, ids);
+        setCountsOnModels(countMap);
+        return;
+    }
+    // belongsToMany
+    const throughTable = rel.throughTable;
+    const relatedKey = rel.relatedKey;
+    if (!isNonEmptyString(throughTable) || !isNonEmptyString(relatedKey))
+        return;
+    const sql = `SELECT ${escapeIdentifier(foreignKey, dialect)} as key, COUNT(*) as count FROM ${escapeIdentifier(throughTable, dialect)} WHERE ${escapeIdentifier(foreignKey, dialect)} IN (${ids.map(() => '?').join(',')}) GROUP BY ${escapeIdentifier(foreignKey, dialect)}`;
+    const countMap = await queryCounts(sql, ids);
+    setCountsOnModels(countMap);
+}
+const getRelationFromModels = (models, relation) => {
+    const firstModel = models[0];
+    const relationFactory = firstModel?.[relation];
+    if (typeof relationFactory !== 'function')
+        return null;
+    const rel = relationFactory();
+    return rel ?? null;
+};
+const assignMorphToGroup = (modelsByType, type, model) => {
+    const existing = modelsByType.get(type);
+    if (existing) {
+        existing.push(model);
+    }
+    else {
+        modelsByType.set(type, [model]);
+    }
+};
+const getModelTable = (model) => {
+    const tableGetter = model.getTable;
+    if (typeof tableGetter !== 'function')
+        return null;
+    const table = tableGetter();
+    return isNonEmptyString(table) ? table : null;
+};
+const buildSingleMap = (results, key) => {
+    const map = new Map();
+    for (const result of results) {
+        const resultId = result.getAttribute(key);
+        if (isKeyValue(resultId)) {
+            map.set(resultId, result);
+        }
+    }
+    return map;
+};
+const buildBucketMap = (results, key) => {
+    const buckets = new Map();
+    for (const result of results) {
+        const resultId = result.getAttribute(key);
+        if (isKeyValue(resultId)) {
+            const existing = buckets.get(resultId) ?? [];
+            existing.push(result);
+            buckets.set(resultId, existing);
+        }
+    }
+    return buckets;
+};
+const setRelationsFromBuckets = (models, relation, localKey, buckets, isMany) => {
+    for (const model of models) {
+        const modelId = model.getAttribute(localKey);
+        if (!isKeyValue(modelId)) {
+            model.setRelation(relation, isMany ? [] : null);
+            continue;
+        }
+        const bucket = buckets.get(modelId) ?? [];
+        if (isMany) {
+            model.setRelation(relation, bucket);
+        }
+        else {
+            model.setRelation(relation, bucket[0] ?? null);
+        }
+    }
+};
+const buildParentToThroughIds = (throughResults, throughForeignKey, secondLocalKey) => {
+    const parentToThroughIds = new Map();
+    for (const throughItem of throughResults) {
+        const parentId = throughItem.getAttribute(throughForeignKey);
+        const throughId = throughItem.getAttribute(secondLocalKey);
+        if (isKeyValue(parentId) && isKeyValue(throughId)) {
+            const existing = parentToThroughIds.get(parentId) ?? [];
+            existing.push(throughId);
+            parentToThroughIds.set(parentId, existing);
+        }
+    }
+    return parentToThroughIds;
+};
+const collectThroughRelated = (throughIds, relatedBuckets) => {
+    const aggregated = [];
+    for (const throughId of throughIds) {
+        const bucket = relatedBuckets.get(throughId);
+        if (bucket !== undefined) {
+            aggregated.push(...bucket);
+        }
+    }
+    return aggregated;
+};
+const setThroughRelations = (models, relation, localKey, parentToThroughIds, relatedBuckets, isMany) => {
+    for (const model of models) {
+        const modelId = model.getAttribute(localKey);
+        if (!isKeyValue(modelId)) {
+            model.setRelation(relation, isMany ? [] : null);
+            continue;
+        }
+        const throughIds = parentToThroughIds.get(modelId) ?? [];
+        if (throughIds.length === 0) {
+            model.setRelation(relation, isMany ? [] : null);
+            continue;
+        }
+        const aggregated = collectThroughRelated(throughIds, relatedBuckets);
+        if (isMany) {
+            model.setRelation(relation, aggregated);
+        }
+        else {
+            model.setRelation(relation, aggregated[0] ?? null);
+        }
+    }
+};
+const buildMorphToGroups = (models, morphType) => {
+    const modelsByType = new Map();
+    for (const model of models) {
+        const type = model.getAttribute(morphType);
+        if (isNonEmptyString(type)) {
+            assignMorphToGroup(modelsByType, type, model);
+        }
+    }
+    return modelsByType;
+};
+const setMorphToRelations = (models, relation, morphId, relatedMap) => {
+    for (const model of models) {
+        const modelId = model.getAttribute(morphId);
+        if (isKeyValue(modelId)) {
+            model.setRelation(relation, relatedMap.get(modelId) ?? null);
+        }
+        else {
+            model.setRelation(relation, null);
+        }
+    }
+};
+const loadMorphToGroup = async (relation, morphId, modelsOfType, relatedModel, constraint) => {
+    const ids = getModelIds(modelsOfType, morphId);
+    if (ids.length === 0)
+        return;
+    const relatedQuery = applyConstraint(relatedModel.query(), constraint);
+    const relatedResults = await relatedQuery.whereIn('id', ids).get();
+    const relatedMap = buildSingleMap(relatedResults, 'id');
+    setMorphToRelations(modelsOfType, relation, morphId, relatedMap);
+};
+const loadMorphToRelation = async (models, relation, rel, constraint) => {
+    if (rel.type !== 'morphTo')
+        return false;
+    const morphType = rel.morphType;
+    const morphId = rel.morphId;
+    const morphMap = rel.morphMap;
+    if (!isNonEmptyString(morphType) ||
+        !isNonEmptyString(morphId) ||
+        morphMap === null ||
+        morphMap === undefined) {
+        return true;
+    }
+    const modelsByType = buildMorphToGroups(models, morphType);
+    const tasks = [...modelsByType.entries()].map(async ([type, modelsOfType]) => {
+        const relatedModel = morphMap[type];
+        if (relatedModel === undefined || typeof relatedModel.query !== 'function') {
+            return Promise.resolve(); //NOSONAR
+        }
+        return loadMorphToGroup(relation, morphId, modelsOfType, relatedModel, constraint);
+    });
+    await Promise.all(tasks);
+    return true;
+};
+const prepareMorphOneMany = (models, rel, localKey, morphId, morphType) => {
+    if (!isNonEmptyString(morphType) || !isNonEmptyString(morphId) || !isNonEmptyString(localKey)) {
+        return { proceed: false };
+    }
+    const ids = getModelIds(models, localKey);
+    if (ids.length === 0)
+        return { proceed: false };
+    const relatedModel = rel.related;
+    if (typeof relatedModel.query !== 'function')
+        return { proceed: false };
+    const tableName = getModelTable(models[0]);
+    if (tableName === null)
+        return { proceed: false };
+    return { proceed: true, ids, relatedModel, tableName };
+};
+const loadMorphOneManyRelation = async (models, relation, rel, constraint) => {
+    if (rel.type !== 'morphOne' && rel.type !== 'morphMany')
+        return false;
+    const morphType = rel.morphType;
+    const morphId = rel.morphId;
+    const localKey = rel.localKey;
+    const prep = prepareMorphOneMany(models, rel, localKey, morphId, morphType);
+    if (!prep.proceed ||
+        prep.ids === undefined ||
+        prep.relatedModel === undefined ||
+        prep.tableName === undefined ||
+        !isNonEmptyString(morphType) ||
+        !isNonEmptyString(morphId) ||
+        !isNonEmptyString(localKey)) {
+        return true;
+    }
+    const ids = prep.ids;
+    const relatedModel = prep.relatedModel;
+    const tableName = prep.tableName;
+    const relatedQuery = applyConstraint(relatedModel.query(), constraint)
+        .where(morphType, '=', tableName)
+        .whereIn(morphId, ids);
+    const relatedResults = await relatedQuery.get();
+    const relatedBuckets = buildBucketMap(relatedResults, morphId);
+    const isMany = rel.type === 'morphMany';
+    setRelationsFromBuckets(models, relation, localKey, relatedBuckets, isMany);
+    return true;
+};
+const loadThroughRelation = async (models, relation, rel, constraint) => {
+    if (rel.type !== 'hasOneThrough' && rel.type !== 'hasManyThrough')
+        return false;
+    const through = rel.through;
+    const throughForeignKey = rel.throughForeignKey;
+    const secondLocalKey = rel.secondLocalKey;
+    const foreignKey = rel.foreignKey;
+    const localKey = rel.localKey;
+    if (through === undefined ||
+        through === null ||
+        !isNonEmptyString(throughForeignKey) ||
+        !isNonEmptyString(secondLocalKey) ||
+        !isNonEmptyString(foreignKey) ||
+        !isNonEmptyString(localKey)) {
+        return true;
+    }
+    const ids = getModelIds(models, localKey);
+    if (ids.length === 0)
+        return true;
+    const throughModel = through;
+    const relatedModel = rel.related;
+    if (typeof throughModel.getTable !== 'function' ||
+        typeof relatedModel.query !== 'function' ||
+        typeof relatedModel.getTable !== 'function') {
+        return true;
+    }
+    const throughTable = throughModel.getTable();
+    const relatedTable = relatedModel.getTable();
+    if (!isNonEmptyString(throughTable) || !isNonEmptyString(relatedTable))
+        return true;
+    let relatedQuery = relatedModel.query();
+    relatedQuery = applyConstraint(relatedQuery, constraint);
+    relatedQuery = relatedQuery
+        .join(throughTable, `${relatedTable}.${foreignKey} = ${throughTable}.${secondLocalKey}`)
+        .whereIn(`${throughTable}.${throughForeignKey}`, ids);
+    const relatedResults = await relatedQuery.get();
+    const throughQuery = throughModel.query().whereIn(throughForeignKey, ids);
+    const throughResults = await throughQuery.get();
+    const parentToThroughIds = buildParentToThroughIds(throughResults, throughForeignKey, secondLocalKey);
+    const relatedBuckets = buildBucketMap(relatedResults, foreignKey);
+    const isMany = rel.type === 'hasManyThrough';
+    setThroughRelations(models, relation, localKey, parentToThroughIds, relatedBuckets, isMany);
+    return true;
+};
+const loadStandardRelation = async (models, relation, rel, constraint) => {
+    const related = rel.related;
+    if (related === null || related === undefined)
+        return false;
+    const foreignKey = rel.foreignKey;
+    const localKey = rel.localKey;
+    if (!isNonEmptyString(foreignKey) || !isNonEmptyString(localKey))
+        return false;
+    const ids = getModelIds(models, localKey);
+    if (ids.length === 0)
+        return true;
+    const relatedModel = rel.related;
+    if (typeof relatedModel.query !== 'function')
+        return false;
+    const relatedQuery = applyConstraint(relatedModel.query(), constraint);
+    const relatedResults = await relatedQuery.whereIn(foreignKey, ids).get();
+    const relatedBuckets = buildBucketMap(relatedResults, foreignKey);
+    const isMany = rel.type === 'hasMany' || rel.type === 'belongsToMany';
+    setRelationsFromBuckets(models, relation, localKey, relatedBuckets, isMany);
+    return true;
+};
+const loadRelation = async (models, relation, constraint) => {
+    if (models.length === 0)
+        return;
+    const rel = getRelationFromModels(models, relation);
+    if (!rel)
+        return;
+    const type = rel.type;
+    if (type === 'morphTo') {
+        await loadMorphToRelation(models, relation, rel, constraint);
+        return;
+    }
+    if (type === 'morphOne' || type === 'morphMany') {
+        await loadMorphOneManyRelation(models, relation, rel, constraint);
+        return;
+    }
+    if (type === 'hasOneThrough' || type === 'hasManyThrough') {
+        await loadThroughRelation(models, relation, rel, constraint);
+        return;
+    }
+    await loadStandardRelation(models, relation, rel, constraint);
+};
+function attachRelationshipMethods(builder, state, db) {
+    builder.with = (relation) => {
+        if (typeof relation === 'string') {
+            state.eagerLoads.push(relation);
+            return builder;
+        }
+        for (const [name, constraint] of Object.entries(relation)) {
+            if (state.eagerLoads.includes(name) === false) {
+                state.eagerLoads.push(name);
+            }
+            state.eagerLoadConstraints[name] = constraint;
+        }
+        return builder;
+    };
+    builder.withCount = (relation) => {
+        state.eagerLoadCounts.push(relation);
+        return builder;
+    };
+    builder.load = async (models, relation, constraint) => {
+        await loadRelation(models, relation, constraint);
+    };
+    builder.loadCount = async (models, relation) => {
+        await loadCounts(models, relation, db);
+    };
 }
 function attachWriteMethods(builder, state, db) {
     const ensureDb = () => {
@@ -605,8 +1003,8 @@ function createBuilder(state, db) {
     attachSoftDeleteMethods(builder, state);
     attachJoinOrderPagingMethods(builder, state);
     attachIntrospectionMethods(builder, state);
-    attachReadExecutionMethods(builder, db);
-    attachRelationshipMethods(builder, state);
+    attachReadExecutionMethods(builder, state, db);
+    attachRelationshipMethods(builder, state, db);
     attachWriteMethods(builder, state, db);
     return builder;
 }
@@ -634,6 +1032,8 @@ export const QueryBuilder = Object.freeze({
             orderByClauses: [],
             joins: [],
             eagerLoads: [],
+            eagerLoadConstraints: {},
+            eagerLoadCounts: [],
             dialect: typeof database?.getType === 'function' ? database.getType() : undefined,
         };
         if (options.softDeleteColumn !== undefined && options.softDeleteColumn.trim().length > 0) {

package/src/orm/Relationships.d.ts

@@ -3,7 +3,7 @@
  * Define how models relate to each other
  */
 import type { IModel, Model, ModelStatic } from './Model';
-export type RelationshipType = 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+export type RelationshipType = 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany' | 'morphOne' | 'morphMany' | 'morphTo' | 'hasOneThrough' | 'hasManyThrough';
 export interface Relation {
     type: RelationshipType;
     related: typeof Model;
@@ -19,6 +19,14 @@ export interface IRelationship {
     localKey: string;
     throughTable?: string;
     relatedKey?: string;
+    morphType?: string;
+    morphId?: string;
+    morphName?: string;
+    morphMap?: Record<string, ModelStatic>;
+    through?: ModelStatic;
+    throughForeignKey?: string;
+    throughLocalKey?: string;
+    secondLocalKey?: string;
 }
 /**
  * HasOne Relationship
@@ -56,4 +64,56 @@ export declare const BelongsTo: Readonly<{
 export declare const BelongsToMany: Readonly<{
     create(relatedModel: ModelStatic, throughTable: string, foreignKey: string, relatedKey: string): IRelationship;
 }>;
+/**
+ * MorphOne Relationship
+ * Polymorphic one-to-one relationship
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export declare const MorphOne: Readonly<{
+    create(relatedModel: ModelStatic, morphName: string, morphType?: string, morphId?: string, localKeyColumn?: string): IRelationship;
+}>;
+/**
+ * MorphMany Relationship
+ * Polymorphic one-to-many relationship
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export declare const MorphMany: Readonly<{
+    create(relatedModel: ModelStatic, morphName: string, morphType?: string, morphId?: string, localKeyColumn?: string): IRelationship;
+}>;
+/**
+ * MorphTo Relationship
+ * Inverse of polymorphic relationships
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export declare const MorphTo: Readonly<{
+    create(morphName: string, morphMap: Record<string, ModelStatic>, morphType?: string, morphId?: string): IRelationship;
+}>;
+/**
+ * HasOneThrough Relationship
+ * Access a distant relation through an intermediate model
+ * Example: Country -> User -> Post (Country hasOneThrough Post through User)
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export declare const HasOneThrough: Readonly<{
+    create(relatedModel: ModelStatic, through: ModelStatic, foreignKey?: string, throughForeignKey?: string, localKey?: string, secondLocalKey?: string): IRelationship;
+}>;
+/**
+ * HasManyThrough Relationship
+ * Access distant relations through an intermediate model
+ * Example: Country -> User -> Post (Country hasManyThrough Posts through Users)
+ * Sealed namespace object following Pattern 2
+ *
+ * @see FRAMEWORK_REFACTOR_FUNCTION_PATTERN.md for Pattern 2 details
+ */
+export declare const HasManyThrough: Readonly<{
+    create(relatedModel: ModelStatic, through: ModelStatic, foreignKey?: string, throughForeignKey?: string, localKey?: string, secondLocalKey?: string): IRelationship;
+}>;
 //# sourceMappingURL=Relationships.d.ts.map

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,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"}
+{"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,GACxB,QAAQ,GACR,SAAS,GACT,WAAW,GACX,eAAe,GACf,UAAU,GACV,WAAW,GACX,SAAS,GACT,eAAe,GACf,gBAAgB,CAAC;AAErB,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;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACvC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;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;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ;yBAEH,WAAW,aACd,MAAM,cACL,MAAM,YACR,MAAM,4BAEf,aAAa;EA0BhB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;yBAEJ,WAAW,aACd,MAAM,cACL,MAAM,YACR,MAAM,4BAEf,aAAa;EA0BhB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;sBAEL,MAAM,YACP,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,cACzB,MAAM,YACR,MAAM,GACf,aAAa;EAuChB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;yBAER,WAAW,WAChB,WAAW,eACP,MAAM,sBACC,MAAM,aACf,MAAM,mBACA,MAAM,GACtB,aAAa;EAqChB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc;yBAET,WAAW,WAChB,WAAW,eACP,MAAM,sBACC,MAAM,aACf,MAAM,mBACA,MAAM,GACtB,aAAa;EAqChB,CAAC"}