schematic-pg 0.1.2 → 0.1.4

package/dist/db/include/executor.js

@@ -0,0 +1,90 @@
+import { mapPgError } from '../errors.js';
+import { mapRows } from '../row-mapper.js';
+import { WhereTranslator } from '../where-translator.js';
+import { dedupeKeys, extractParentKeys, stitch } from './hydrator.js';
+export async function loadIncludes(parentRows, plan, pool) {
+    for (const childPlan of plan.children) {
+        const relation = childPlan.relation;
+        if (!relation) {
+            continue;
+        }
+        const parentKeys = extractParentKeys(parentRows, relation);
+        if (parentKeys.length === 0) {
+            assignEmptyRelation(parentRows, relation);
+            continue;
+        }
+        const childRows = await fetchRelationRows(childPlan, parentKeys, pool);
+        await loadIncludes(childRows, childPlan, pool);
+        stitch(parentRows, childRows, relation);
+    }
+}
+function assignEmptyRelation(parentRows, relation) {
+    for (const parent of parentRows) {
+        parent[relation.name] = relation.unique ? null : [];
+    }
+}
+async function fetchRelationRows(node, parentKeys, pool) {
+    const relation = node.relation;
+    if (!relation) {
+        return [];
+    }
+    const query = buildRelationSelect(node, parentKeys);
+    const rows = await executeQuery(pool, query.sql, query.params, node.model);
+    return mapRows(rows, node.model);
+}
+function buildRelationSelect(node, parentKeys) {
+    const relation = node.relation;
+    const foreignField = node.model.fieldByName.get(relation.foreignKey);
+    if (!foreignField) {
+        throw new Error(`Unknown foreign key field "${relation.foreignKey}" on model ${node.model.name}`);
+    }
+    const dedupedKeys = dedupeKeys(parentKeys);
+    const params = [dedupedKeys];
+    const whereTranslator = new WhereTranslator(node.model, 2);
+    const nestedWhere = whereTranslator.translate(node.where);
+    params.push(...nestedWhere.params);
+    const clauses = [`${foreignField.columnName} = ANY($1)`];
+    if (nestedWhere.sql) {
+        clauses.push(nestedWhere.sql);
+    }
+    const orderByClause = buildOrderByClause(node);
+    let sql = `SELECT * FROM ${node.model.quotedTableName} WHERE ${clauses.join(' AND ')}`;
+    if (orderByClause) {
+        sql += ` ${orderByClause}`;
+    }
+    if (node.take !== undefined) {
+        params.push(node.take);
+        sql += ` LIMIT $${params.length}`;
+    }
+    if (node.skip !== undefined) {
+        params.push(node.skip);
+        sql += ` OFFSET $${params.length}`;
+    }
+    return { sql, params };
+}
+function buildOrderByClause(plan) {
+    if (!plan.orderBy) {
+        return '';
+    }
+    const entries = Array.isArray(plan.orderBy) ? plan.orderBy : [plan.orderBy];
+    const parts = [];
+    for (const entry of entries) {
+        for (const [fieldName, direction] of Object.entries(entry)) {
+            const field = plan.model.fieldByName.get(fieldName);
+            if (!field) {
+                throw new Error(`Unknown orderBy field "${fieldName}" on model ${plan.model.name}`);
+            }
+            parts.push(`${field.columnName} ${direction.toUpperCase()}`);
+        }
+    }
+    return parts.length > 0 ? `ORDER BY ${parts.join(', ')}` : '';
+}
+async function executeQuery(pool, sql, params, model) {
+    try {
+        const result = await pool.query(sql, params);
+        return result.rows;
+    }
+    catch (error) {
+        throw mapPgError(error, model.name, model.columnToField);
+    }
+}

package/dist/db/include/hydrator.d.ts

@@ -0,0 +1,4 @@
+import type { RelationMeta } from '../model-meta.js';
+export declare function stitch(parents: Record<string, unknown>[], children: Record<string, unknown>[], relation: RelationMeta): void;
+export declare function dedupeKeys(keys: unknown[]): unknown[];
+export declare function extractParentKeys(parents: Record<string, unknown>[], relation: RelationMeta): unknown[];

package/dist/db/include/hydrator.js

@@ -0,0 +1,34 @@
+export function stitch(parents, children, relation) {
+    const childrenByForeignKey = bucketChildrenByForeignKey(children, relation);
+    for (const parent of parents) {
+        const localValue = parent[relation.localKey];
+        const bucket = localValue == null ? [] : (childrenByForeignKey.get(localValue) ?? []);
+        if (relation.unique) {
+            parent[relation.name] = bucket[0] ?? null;
+            continue;
+        }
+        parent[relation.name] = bucket;
+    }
+}
+function bucketChildrenByForeignKey(children, relation) {
+    const buckets = new Map();
+    for (const child of children) {
+        const foreignValue = child[relation.foreignKey];
+        if (foreignValue == null) {
+            continue;
+        }
+        const bucket = buckets.get(foreignValue);
+        if (bucket) {
+            bucket.push(child);
+            continue;
+        }
+        buckets.set(foreignValue, [child]);
+    }
+    return buckets;
+}
+export function dedupeKeys(keys) {
+    return [...new Set(keys.filter((key) => key != null))];
+}
+export function extractParentKeys(parents, relation) {
+    return dedupeKeys(parents.map((parent) => parent[relation.localKey]));
+}

package/dist/db/include/json-agg.d.ts

@@ -0,0 +1,5 @@
+import type { Pool } from 'pg';
+import type { ModelMeta } from '../model-meta.js';
+import type { FindArgs } from '../query-builder.js';
+import type { LoadNode } from './planner.js';
+export declare function fetchRootWithJsonAgg<T extends Record<string, unknown>>(model: ModelMeta, plan: LoadNode, args: FindArgs, pool: Pool): Promise<T[]>;

package/dist/db/include/json-agg.js

@@ -0,0 +1,101 @@
+import { mapPgError } from '../errors.js';
+import { QueryBuilder } from '../query-builder.js';
+import { mapRow } from '../row-mapper.js';
+const ROOT_ALIAS = 'root';
+export async function fetchRootWithJsonAgg(model, plan, args, pool) {
+    const query = buildJsonAggRootQuery(model, plan, args);
+    const rows = await executeQuery(pool, query.sql, query.params, model);
+    return rows.map((row) => hydrateJsonAggRow(row, model, plan));
+}
+function buildJsonAggRootQuery(model, plan, args) {
+    const builder = new QueryBuilder(model);
+    const baseQuery = builder.select(args);
+    const match = baseQuery.sql.match(/^SELECT \* FROM ([^\s]+)([\s\S]*)$/);
+    if (!match || plan.children.length === 0) {
+        return baseQuery;
+    }
+    const tableRef = match[1];
+    const rest = match[2] ?? '';
+    const lateralJoins = plan.children.map((child) => buildRootLateralJoin(model, child));
+    const sql = [
+        `SELECT ${ROOT_ALIAS}.*, ${lateralJoins.map((join) => join.select).join(', ')}`,
+        `FROM ${tableRef} ${ROOT_ALIAS}`,
+        lateralJoins.map((join) => join.join).join(' '),
+        rest.trim(),
+    ]
+        .filter((part) => part.length > 0)
+        .join(' ');
+    return { sql, params: baseQuery.params };
+}
+function buildRootLateralJoin(parentModel, node) {
+    const relation = node.relation;
+    const lateralAlias = `${relation.name}_data`;
+    const expression = buildRelationJsonExpression(parentModel, node, ROOT_ALIAS);
+    return {
+        select: `${lateralAlias}.${relation.name}`,
+        join: `LEFT JOIN LATERAL (SELECT ${expression} AS ${relation.name}) ${lateralAlias} ON true`,
+    };
+}
+function buildRelationJsonExpression(parentModel, node, parentAlias) {
+    const relation = node.relation;
+    const childAlias = `${relation.name}_row`;
+    const localField = parentModel.fieldByName.get(relation.localKey);
+    const foreignField = node.model.fieldByName.get(relation.foreignKey);
+    if (!localField || !foreignField) {
+        throw new Error(`Invalid relation "${relation.name}" between ${parentModel.name} and ${node.model.name}`);
+    }
+    const rowJson = buildRowJsonExpression(node, childAlias);
+    const whereClause = `${childAlias}.${foreignField.columnName} = ${parentAlias}.${localField.columnName}`;
+    if (relation.unique) {
+        return `(SELECT ${rowJson} FROM ${node.model.quotedTableName} ${childAlias} WHERE ${whereClause} LIMIT 1)`;
+    }
+    return `(SELECT COALESCE(json_agg(${rowJson}), '[]'::json) FROM ${node.model.quotedTableName} ${childAlias} WHERE ${whereClause})`;
+}
+function buildRowJsonExpression(node, rowAlias) {
+    if (node.children.length === 0) {
+        return `to_jsonb(${rowAlias})`;
+    }
+    const fieldPairs = node.model.fields.map((field) => `'${field.name}', ${rowAlias}.${field.columnName}`);
+    for (const child of node.children) {
+        const relation = child.relation;
+        fieldPairs.push(`'${relation.name}', ${buildRelationJsonExpression(node.model, child, rowAlias)}`);
+    }
+    return `json_build_object(${fieldPairs.join(', ')})`;
+}
+function hydrateJsonAggRow(row, model, plan) {
+    const mapped = mapRow(row, model);
+    for (const child of plan.children) {
+        const relation = child.relation;
+        mapped[relation.name] = hydrateRelationValue(row[relation.name], child, relation.unique);
+    }
+    return mapped;
+}
+function hydrateRelationValue(rawValue, plan, unique) {
+    if (rawValue == null) {
+        return unique ? null : [];
+    }
+    if (unique) {
+        return hydrateJsonObject(rawValue, plan);
+    }
+    if (!Array.isArray(rawValue)) {
+        return [];
+    }
+    return rawValue.map((entry) => hydrateJsonObject(entry, plan));
+}
+function hydrateJsonObject(value, plan) {
+    const mapped = mapRow(value, plan.model);
+    for (const child of plan.children) {
+        const relation = child.relation;
+        mapped[relation.name] = hydrateRelationValue(value[relation.name], child, relation.unique);
+    }
+    return mapped;
+}
+async function executeQuery(pool, sql, params, model) {
+    try {
+        const result = await pool.query(sql, params);
+        return result.rows;
+    }
+    catch (error) {
+        throw mapPgError(error, model.name, model.columnToField);
+    }
+}

package/dist/db/include/load.d.ts

@@ -0,0 +1,8 @@
+import type { Pool } from 'pg';
+import type { ModelMeta } from '../model-meta.js';
+import type { FindArgs } from '../query-builder.js';
+import type { IncludeInput, IncludeOptions } from './types.js';
+export declare function fetchWithIncludes<T extends Record<string, unknown>>(model: ModelMeta, registry: Map<string, ModelMeta>, pool: Pool, rootArgs: FindArgs & {
+    include?: IncludeInput;
+}, options?: IncludeOptions): Promise<T[]>;
+export declare function attachIncludes<T extends Record<string, unknown>>(model: ModelMeta, registry: Map<string, ModelMeta>, pool: Pool, rootRows: T[], include: IncludeInput, rootArgs: FindArgs, options?: IncludeOptions): Promise<T[]>;

package/dist/db/include/load.js

@@ -0,0 +1,46 @@
+import { mapPgError } from '../errors.js';
+import { QueryBuilder } from '../query-builder.js';
+import { mapRows } from '../row-mapper.js';
+import { loadIncludes } from './executor.js';
+import { fetchRootWithJsonAgg } from './json-agg.js';
+import { buildLoadPlan } from './planner.js';
+export async function fetchWithIncludes(model, registry, pool, rootArgs, options = {}) {
+    if (!rootArgs.include) {
+        throw new Error('fetchWithIncludes requires include');
+    }
+    const plan = buildLoadPlan(model, rootArgs.include, registry, options);
+    plan.where = rootArgs.where;
+    plan.orderBy = rootArgs.orderBy;
+    plan.take = rootArgs.take;
+    plan.skip = rootArgs.skip;
+    if (plan.strategy === 'join') {
+        return fetchRootWithJsonAgg(model, plan, rootArgs, pool);
+    }
+    const rows = await executeRootSelect(model, pool, rootArgs);
+    const mapped = mapRows(rows, model);
+    await loadIncludes(mapped, plan, pool);
+    return mapped;
+}
+export async function attachIncludes(model, registry, pool, rootRows, include, rootArgs, options = {}) {
+    if (rootRows.length === 0) {
+        return rootRows;
+    }
+    const plan = buildLoadPlan(model, include, registry, options);
+    plan.where = rootArgs.where;
+    plan.orderBy = rootArgs.orderBy;
+    plan.take = rootArgs.take;
+    plan.skip = rootArgs.skip;
+    await loadIncludes(rootRows, plan, pool);
+    return rootRows;
+}
+async function executeRootSelect(model, pool, args) {
+    const builder = new QueryBuilder(model);
+    const query = builder.select(args);
+    try {
+        const result = await pool.query(query.sql, query.params);
+        return result.rows;
+    }
+    catch (error) {
+        throw mapPgError(error, model.name, model.columnToField);
+    }
+}

package/dist/db/include/planner.d.ts

@@ -0,0 +1,16 @@
+import type { ModelMeta } from '../model-meta.js';
+import type { OrderByInput } from '../query-builder.js';
+import type { WhereInput } from '../where-translator.js';
+import type { IncludeInput, IncludeOptions, RelationLoadStrategy } from './types.js';
+export interface LoadNode {
+    model: ModelMeta;
+    relation?: ModelMeta['relations'][number];
+    where?: WhereInput;
+    orderBy?: OrderByInput | OrderByInput[];
+    take?: number;
+    skip?: number;
+    children: LoadNode[];
+    strategy: RelationLoadStrategy;
+}
+export type ModelRegistry = Map<string, ModelMeta>;
+export declare function buildLoadPlan(model: ModelMeta, include: IncludeInput | undefined, registry: ModelRegistry, options?: IncludeOptions, depth?: number): LoadNode;

package/dist/db/include/planner.js

@@ -0,0 +1,48 @@
+import { MAX_INCLUDE_DEPTH } from '../../constants.js';
+export function buildLoadPlan(model, include, registry, options = {}, depth = 0) {
+    if (depth > MAX_INCLUDE_DEPTH) {
+        throw new Error(`Include depth exceeds maximum of ${MAX_INCLUDE_DEPTH} on model ${model.name}`);
+    }
+    const children = [];
+    if (include) {
+        for (const [relationName, relationInclude] of Object.entries(include)) {
+            const relation = model.relationByName.get(relationName);
+            if (!relation) {
+                throw new Error(`Unknown include relation "${relationName}" on model ${model.name}`);
+            }
+            const targetModel = registry.get(relation.targetModel);
+            if (!targetModel) {
+                throw new Error(`Unknown target model "${relation.targetModel}" for relation "${relationName}"`);
+            }
+            const relationArgs = normalizeRelationInclude(relationInclude);
+            const childPlan = buildLoadPlan(targetModel, relationArgs.include, registry, options, depth + 1);
+            childPlan.relation = relation;
+            childPlan.where = relationArgs.where;
+            childPlan.orderBy = relationArgs.orderBy;
+            childPlan.take = relationArgs.take;
+            childPlan.skip = relationArgs.skip;
+            children.push(childPlan);
+        }
+    }
+    return {
+        model,
+        children,
+        strategy: chooseStrategy(children, options),
+    };
+}
+function normalizeRelationInclude(include) {
+    if (typeof include === 'boolean') {
+        return {};
+    }
+    return include;
+}
+function chooseStrategy(children, options) {
+    if (options.relationLoadStrategy) {
+        return options.relationLoadStrategy;
+    }
+    const hasManyChildren = children.filter((child) => child.relation?.kind === 'hasMany');
+    if (hasManyChildren.length >= 2) {
+        return 'split';
+    }
+    return 'split';
+}

package/dist/db/include/types.d.ts

@@ -0,0 +1,14 @@
+import type { OrderByInput } from '../query-builder.js';
+import type { WhereInput } from '../where-translator.js';
+export type RelationLoadStrategy = 'split' | 'join';
+export interface RelationIncludeArgs {
+    where?: WhereInput;
+    orderBy?: OrderByInput | OrderByInput[];
+    take?: number;
+    skip?: number;
+    include?: IncludeInput;
+}
+export type IncludeInput = Record<string, boolean | RelationIncludeArgs>;
+export interface IncludeOptions {
+    relationLoadStrategy?: RelationLoadStrategy;
+}

package/dist/db/include/types.js

@@ -0,0 +1 @@
+export {};

package/dist/db/model-client.d.ts

@@ -1,18 +1,20 @@
 import type { Pool } from 'pg';
+import type { IncludeInput, IncludeOptions } from './include/types.js';
 import type { ModelMeta } from './model-meta.js';
+export type ModelRegistry = Map<string, ModelMeta>;
+export interface SelectArgs<TWhere, TOrderBy> {
+    where?: TWhere;
+    orderBy?: TOrderBy | TOrderBy[];
+    take?: number;
+    skip?: number;
+    include?: IncludeInput;
+    relationLoadStrategy?: IncludeOptions['relationLoadStrategy'];
+}
 export interface ModelClient<T, TCreate, TUpdate, TWhere, TOrderBy> {
     create(data: TCreate): Promise<T>;
-    findUnique(where: Record<string, unknown>): Promise<T | null>;
-    findFirst(args?: {
-        where?: TWhere;
-        orderBy?: TOrderBy;
-    }): Promise<T | null>;
-    findMany(args?: {
-        where?: TWhere;
-        orderBy?: TOrderBy | TOrderBy[];
-        take?: number;
-        skip?: number;
-    }): Promise<T[]>;
+    findUnique(where: Record<string, unknown>, args?: Omit<SelectArgs<TWhere, TOrderBy>, 'where'>): Promise<T | null>;
+    findFirst(args?: SelectArgs<TWhere, TOrderBy>): Promise<T | null>;
+    findMany(args?: SelectArgs<TWhere, TOrderBy>): Promise<T[]>;
     count(args?: {
         where?: TWhere;
     }): Promise<number>;
@@ -33,4 +35,4 @@ export interface ModelClient<T, TCreate, TUpdate, TWhere, TOrderBy> {
         count: number;
     }>;
 }
-export declare function createModelClient<T, TCreate, TUpdate, TWhere, TOrderBy>(model: ModelMeta, pool: Pool): ModelClient<T, TCreate, TUpdate, TWhere, TOrderBy>;
+export declare function createModelClient<T, TCreate, TUpdate, TWhere, TOrderBy>(model: ModelMeta, pool: Pool, registry?: ModelRegistry): ModelClient<T, TCreate, TUpdate, TWhere, TOrderBy>;

package/dist/db/model-client.js

@@ -1,7 +1,8 @@
 import { mapPgError } from './errors.js';
+import { fetchWithIncludes } from './include/load.js';
 import { QueryBuilder } from './query-builder.js';
 import { mapRow, mapRows } from './row-mapper.js';
-export function createModelClient(model, pool) {
+export function createModelClient(model, pool, registry) {
     const builder = new QueryBuilder(model);
     async function execute(sql, params) {
         try {
@@ -12,35 +13,40 @@ export function createModelClient(model, pool) {
             throw mapPgError(error, model.name, model.columnToField);
         }
     }
+    async function selectRows(args = {}) {
+        const findArgs = toFindArgs(args);
+        if (args.include && registry) {
+            return fetchWithIncludes(model, registry, pool, {
+                ...findArgs,
+                include: args.include,
+            }, {
+                relationLoadStrategy: args.relationLoadStrategy,
+            });
+        }
+        const query = builder.select(findArgs);
+        const rows = await execute(query.sql, query.params);
+        return mapRows(rows, model);
+    }
     return {
         async create(data) {
             const query = builder.insert(data);
             const rows = await execute(query.sql, query.params);
             return mapRow(rows[0], model);
         },
-        async findUnique(where) {
-            const query = builder.select({ where, take: 1 });
-            const rows = await execute(query.sql, query.params);
-            return rows[0] ? mapRow(rows[0], model) : null;
-        },
-        async findFirst(args) {
-            const query = builder.select({
-                where: args?.where,
-                orderBy: args?.orderBy,
+        async findUnique(where, args = {}) {
+            const rows = await selectRows({
+                ...args,
+                where: where,
                 take: 1,
             });
-            const rows = await execute(query.sql, query.params);
-            return rows[0] ? mapRow(rows[0], model) : null;
+            return rows[0] ?? null;
         },
-        async findMany(args) {
-            const query = builder.select({
-                where: args?.where,
-                orderBy: args?.orderBy,
-                take: args?.take,
-                skip: args?.skip,
-            });
-            const rows = await execute(query.sql, query.params);
-            return mapRows(rows, model);
+        async findFirst(args = {}) {
+            const rows = await selectRows({ ...args, take: 1 });
+            return rows[0] ?? null;
+        },
+        async findMany(args = {}) {
+            return selectRows(args);
         },
         async count(args) {
             const query = builder.count({ where: args?.where });
@@ -81,3 +87,11 @@ export function createModelClient(model, pool) {
         },
     };
 }
+function toFindArgs(args) {
+    return {
+        where: args.where,
+        orderBy: args.orderBy,
+        take: args.take,
+        skip: args.skip,
+    };
+}

package/dist/db/model-meta.d.ts

@@ -1,4 +1,14 @@
 import type { Model, Schema, TypeExpr } from '../schema-dsl/ast.js';
+export type RelationKind = 'belongsTo' | 'hasOne' | 'hasMany';
+export interface RelationMeta {
+    name: string;
+    kind: RelationKind;
+    targetModel: string;
+    localKey: string;
+    foreignKey: string;
+    unique: boolean;
+    relationName?: string;
+}
 export interface FieldMeta {
     name: string;
     columnName: string;
@@ -20,6 +30,7 @@ export interface ModelMetaSnapshot {
     fields: FieldMeta[];
     fieldByName: Record<string, FieldMeta>;
     columnToField: Record<string, string>;
+    relations: RelationMeta[];
 }
 export interface ModelMeta {
     name: string;
@@ -29,6 +40,8 @@ export interface ModelMeta {
     fields: FieldMeta[];
     fieldByName: Map<string, FieldMeta>;
     columnToField: Map<string, string>;
+    relations: RelationMeta[];
+    relationByName: Map<string, RelationMeta>;
 }
 export declare function buildModelMeta(model: Model, schema: Schema): ModelMeta;
 export declare function buildModelMetaSnapshot(model: Model, schema: Schema): ModelMetaSnapshot;

package/dist/db/model-meta.js

@@ -1,4 +1,5 @@
 import { fieldHasAttribute, getModelNames, getPrimaryKey, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
+import { buildRelations } from './utils/relations.js';
 import { toColumnName, toTableName } from './utils/naming.js';
 const NUMERIC_TYPES = new Set(['INTEGER', 'SERIAL', 'SMALLINT', 'DECIMAL']);
 const STRING_TYPES = new Set(['UUID', 'VARCHAR', 'TEXT']);
@@ -14,6 +15,7 @@ export function buildModelMetaSnapshot(model, schema) {
     const fields = storedFields.map((field) => toFieldMeta(field, enumNames, primaryKeyFields));
     const fieldByName = Object.fromEntries(fields.map((field) => [field.name, field]));
     const columnToField = Object.fromEntries(fields.map((field) => [field.columnName, field.name]));
+    const relations = buildRelations(model, schema);
     return {
         name: model.name,
         tableName: toTableName(model.name),
@@ -22,11 +24,15 @@ export function buildModelMetaSnapshot(model, schema) {
         fields,
         fieldByName,
         columnToField,
+        relations,
     };
 }
 export function hydrateModelMeta(snapshot) {
+    const relations = snapshot.relations ?? [];
     return {
         ...snapshot,
+        relations,
+        relationByName: new Map(relations.map((relation) => [relation.name, relation])),
         fieldByName: new Map(Object.entries(snapshot.fieldByName)),
         columnToField: new Map(Object.entries(snapshot.columnToField)),
     };

package/dist/db/type-generator.d.ts

@@ -10,6 +10,8 @@ export declare class TypeGenerator {
     private generateUpdateInput;
     private generateWhereInput;
     private generateOrderByInput;
+    private generateIncludeArgs;
+    private generateInclude;
     private toTsType;
     private mapTypeExpr;
     private isFilterable;

package/dist/db/type-generator.js

@@ -7,12 +7,16 @@ export class TypeGenerator {
     }
     generate() {
         const enumBlocks = this.schema.enums.map((enumDef) => this.generateEnumType(enumDef.name, enumDef.values));
+        const includeArgsBlocks = this.schema.models.map((model) => this.generateIncludeArgs(model));
+        const includeBlocks = this.schema.models.map((model) => this.generateInclude(model));
         const modelBlocks = this.schema.models.flatMap((model) => this.generateModelTypes(model));
         return [
             '// Auto-generated by TypeGenerator. Do not edit manually.',
             '',
             ...enumBlocks,
             ...modelBlocks,
+            ...includeArgsBlocks,
+            ...includeBlocks,
         ].join('\n');
     }
     generateEnumType(name, values) {
@@ -62,6 +66,18 @@ export class TypeGenerator {
         const lines = fields.map((field) => `  ${field.name}?: 'asc' | 'desc';`);
         return `export interface ${modelName}OrderByInput {\n${lines.join('\n')}\n}\n`;
     }
+    generateIncludeArgs(model) {
+        return `export interface ${model.name}IncludeArgs {\n  where?: ${model.name}WhereInput;\n  orderBy?: ${model.name}OrderByInput | ${model.name}OrderByInput[];\n  take?: number;\n  skip?: number;\n  include?: ${model.name}Include;\n}\n`;
+    }
+    generateInclude(model) {
+        const modelNames = getModelNames(this.schema);
+        const relationFields = model.fields.filter((field) => modelNames.has(field.type.name));
+        if (relationFields.length === 0) {
+            return `export interface ${model.name}Include {}\n`;
+        }
+        const lines = relationFields.map((field) => `  ${field.name}?: boolean | ${field.type.name}IncludeArgs;`);
+        return `export interface ${model.name}Include {\n${lines.join('\n')}\n}\n`;
+    }
     toTsType(field, mode) {
         const base = this.mapTypeExpr(field.type);
         if (field.type.optional) {

package/dist/db/utils/relations.d.ts

@@ -0,0 +1,3 @@
+import type { Model, Schema } from '../../schema-dsl/ast.js';
+import type { RelationMeta } from '../model-meta.js';
+export declare function buildRelations(model: Model, schema: Schema): RelationMeta[];