schematic-pg 0.1.2 → 0.1.4

package/dist/api-generator/route-generator.js

@@ -2,6 +2,7 @@ import { PACKAGE_NAME } from '../constants.js';
 import { getPrimaryKey } from '../sql-generator/utils/ast-helpers.js';
 import { getClientExportName } from '../db/type-generator.js';
 import { toRouteBasePath, toRouteFileName, toRouteImportName } from '../api/utils/route-naming.js';
+import { toModelConstantPrefix } from './utils/api-fields.js';
 import { hasPolicies } from './utils/policy.js';
 export class RouteGenerator {
     model;
@@ -19,13 +20,17 @@ export class RouteGenerator {
         const pathParams = primaryKey.fields.map((field) => `:${field}`).join('/');
         const whereFromParams = primaryKey.fields.map((field) => `${field}: params.${field}`).join(', ');
         const paramSchemaName = `${this.model.name}ParamSchema`;
+        const listQuerySchemaName = `${this.model.name}ListQuerySchema`;
         const modelHasPolicies = hasPolicies(this.model);
+        const constantPrefix = toModelConstantPrefix(this.model.name);
         return [
             '// Auto-generated by RouteGenerator. Do not edit manually.',
             "import { Hono } from 'hono';",
             `import type { AppEnv } from '${PACKAGE_NAME}/api/types';`,
-            `import { validateJson, validateParam } from '${PACKAGE_NAME}/api/middleware/validate';`,
+            `import { validateJson, validateParam, validateQuery } from '${PACKAGE_NAME}/api/middleware/validate';`,
             `import { notFoundResponse } from '${PACKAGE_NAME}/api/middleware/errors';`,
+            `import { buildListQuery } from '${PACKAGE_NAME}/api/utils/list-query';`,
+            `import { omitFields, omitFieldsMany } from '${PACKAGE_NAME}/api/utils/omit-fields';`,
             ...(modelHasPolicies
                 ? [
                     `import { assertPolicy, mergeWhere, resolvePolicyWhere } from '${PACKAGE_NAME}/api/auth/policy';`,
@@ -35,46 +40,75 @@ export class RouteGenerator {
             `  ${this.model.name}CreateSchema,`,
             `  ${this.model.name}UpdateSchema,`,
             `  ${paramSchemaName},`,
+            `  ${listQuerySchemaName},`,
+            `  ${constantPrefix}_LIST_QUERY_FIELDS,`,
+            `  ${constantPrefix}_OMIT_FIELDS,`,
+            `  ${constantPrefix}_SORTABLE_FIELDS,`,
             `} from '../schemas/validation.js';`,
             '',
             'const router = new Hono<AppEnv>();',
             '',
-            ...this.generateListRoute(clientKey, modelHasPolicies),
+            ...this.generateListRoute(clientKey, modelHasPolicies, listQuerySchemaName, constantPrefix),
             '',
-            ...this.generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies),
+            ...this.generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix),
             '',
-            ...this.generateCreateRoute(clientKey, modelHasPolicies),
+            ...this.generateCreateRoute(clientKey, modelHasPolicies, constantPrefix),
             '',
-            ...this.generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies),
+            ...this.generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix),
             '',
-            ...this.generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies),
+            ...this.generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix),
             '',
             'export default router;',
             '',
         ].join('\n');
     }
-    generateListRoute(clientKey, modelHasPolicies) {
+    jsonRow(variableName, constantPrefix, statusCode) {
+        const payload = `omitFields(${variableName}, ${constantPrefix}_OMIT_FIELDS)`;
+        if (statusCode === undefined) {
+            return `c.json(${payload})`;
+        }
+        return `c.json(${payload}, ${statusCode})`;
+    }
+    jsonRows(variableName, constantPrefix) {
+        return `c.json(omitFieldsMany(${variableName}, ${constantPrefix}_OMIT_FIELDS))`;
+    }
+    generateListRoute(clientKey, modelHasPolicies, listQuerySchemaName, constantPrefix) {
+        const listQueryBlock = [
+            `  const query = c.req.valid('query');`,
+            `  const { where, orderBy, take, skip } = buildListQuery(`,
+            `    query,`,
+            `    ${constantPrefix}_LIST_QUERY_FIELDS,`,
+            `    ${constantPrefix}_SORTABLE_FIELDS,`,
+            `  );`,
+        ];
         if (!modelHasPolicies) {
             return [
-                "router.get('/', async (c) => {",
+                `router.get('/', validateQuery(${listQuerySchemaName}), async (c) => {`,
                 '  const db = c.get(\'db\');',
-                `  const rows = await db.${clientKey}.findMany();`,
-                '  return c.json(rows);',
+                ...listQueryBlock,
+                `  const rows = await db.${clientKey}.findMany({ where, orderBy, take, skip });`,
+                `  return ${this.jsonRows('rows', constantPrefix)};`,
                 '});',
             ];
         }
         return [
-            "router.get('/', async (c) => {",
+            `router.get('/', validateQuery(${listQuerySchemaName}), async (c) => {`,
             '  const db = c.get(\'db\');',
             '  const auth = c.get(\'auth\');',
             `  const policy = assertPolicy('${this.model.name}', auth.role, 'select');`,
             '  const policyWhere = resolvePolicyWhere(policy, auth);',
-            `  const rows = await db.${clientKey}.findMany({ where: policyWhere });`,
-            '  return c.json(rows);',
+            ...listQueryBlock,
+            `  const rows = await db.${clientKey}.findMany({`,
+            '    where: mergeWhere(where, policyWhere),',
+            '    orderBy,',
+            '    take,',
+            '    skip,',
+            '  });',
+            `  return ${this.jsonRows('rows', constantPrefix)};`,
             '});',
         ];
     }
-    generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies) {
+    generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
         if (!modelHasPolicies) {
             return [
                 `router.get('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
@@ -84,7 +118,7 @@ export class RouteGenerator {
                 '  if (!row) {',
                 '    return notFoundResponse(c);',
                 '  }',
-                '  return c.json(row);',
+                `  return ${this.jsonRow('row', constantPrefix)};`,
                 '});',
             ];
         }
@@ -99,18 +133,18 @@ export class RouteGenerator {
             '  if (!row) {',
             '    return notFoundResponse(c);',
             '  }',
-            '  return c.json(row);',
+            `  return ${this.jsonRow('row', constantPrefix)};`,
             '});',
         ];
     }
-    generateCreateRoute(clientKey, modelHasPolicies) {
+    generateCreateRoute(clientKey, modelHasPolicies, constantPrefix) {
         if (!modelHasPolicies) {
             return [
                 `router.post('/', validateJson(${this.model.name}CreateSchema), async (c) => {`,
                 '  const db = c.get(\'db\');',
                 '  const body = c.req.valid(\'json\');',
                 `  const row = await db.${clientKey}.create(body);`,
-                '  return c.json(row, 201);',
+                `  return ${this.jsonRow('row', constantPrefix, 201)};`,
                 '});',
             ];
         }
@@ -121,11 +155,11 @@ export class RouteGenerator {
             `  assertPolicy('${this.model.name}', auth.role, 'insert');`,
             '  const body = c.req.valid(\'json\');',
             `  const row = await db.${clientKey}.create(body);`,
-            '  return c.json(row, 201);',
+            `  return ${this.jsonRow('row', constantPrefix, 201)};`,
             '});',
         ];
     }
-    generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies) {
+    generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
         if (!modelHasPolicies) {
             return [
                 `router.put('/${pathParams}', validateParam(${paramSchemaName}), validateJson(${this.model.name}UpdateSchema), async (c) => {`,
@@ -133,7 +167,7 @@ export class RouteGenerator {
                 '  const params = c.req.valid(\'param\');',
                 '  const body = c.req.valid(\'json\');',
                 `  const row = await db.${clientKey}.update({ where: { ${whereFromParams} }, data: body });`,
-                '  return c.json(row);',
+                `  return ${this.jsonRow('row', constantPrefix)};`,
                 '});',
             ];
         }
@@ -146,18 +180,18 @@ export class RouteGenerator {
             '  const params = c.req.valid(\'param\');',
             '  const body = c.req.valid(\'json\');',
             `  const row = await db.${clientKey}.update({ where: mergeWhere({ ${whereFromParams} }, policyWhere), data: body });`,
-            '  return c.json(row);',
+            `  return ${this.jsonRow('row', constantPrefix)};`,
             '});',
         ];
     }
-    generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies) {
+    generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies, constantPrefix) {
         if (!modelHasPolicies) {
             return [
                 `router.delete('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
                 '  const db = c.get(\'db\');',
                 '  const params = c.req.valid(\'param\');',
                 `  const row = await db.${clientKey}.delete({ ${whereFromParams} });`,
-                '  return c.json(row);',
+                `  return ${this.jsonRow('row', constantPrefix)};`,
                 '});',
             ];
         }
@@ -169,7 +203,7 @@ export class RouteGenerator {
             '  const policyWhere = resolvePolicyWhere(policy, auth);',
             '  const params = c.req.valid(\'param\');',
             `  const row = await db.${clientKey}.delete(mergeWhere({ ${whereFromParams} }, policyWhere));`,
-            '  return c.json(row);',
+            `  return ${this.jsonRow('row', constantPrefix)};`,
             '});',
         ];
     }

package/dist/api-generator/utils/api-fields.d.ts

@@ -0,0 +1,8 @@
+import type { Field, Model, Schema } from '../../schema-dsl/ast.js';
+export declare function isStoredScalarField(field: Field, schema: Schema): boolean;
+export declare function isUnfilterable(field: Field): boolean;
+export declare function isOmitted(field: Field): boolean;
+export declare function getFilterableFields(model: Model, schema: Schema): Field[];
+export declare function getOmittedFields(model: Model, schema: Schema): Field[];
+export declare function getSortableFieldNames(model: Model, schema: Schema): string[];
+export declare function toModelConstantPrefix(modelName: string): string;

package/dist/api-generator/utils/api-fields.js

@@ -0,0 +1,25 @@
+import { fieldHasAttribute, getModelNames, getStoredFields, } from '../../sql-generator/utils/ast-helpers.js';
+export function isStoredScalarField(field, schema) {
+    const modelNames = getModelNames(schema);
+    return !modelNames.has(field.type.name);
+}
+export function isUnfilterable(field) {
+    return fieldHasAttribute(field, 'unfilterable') || fieldHasAttribute(field, 'omit');
+}
+export function isOmitted(field) {
+    return fieldHasAttribute(field, 'omit');
+}
+export function getFilterableFields(model, schema) {
+    return getStoredFields(model, getModelNames(schema)).filter((field) => isStoredScalarField(field, schema) && !isUnfilterable(field));
+}
+export function getOmittedFields(model, schema) {
+    return getStoredFields(model, getModelNames(schema)).filter((field) => isStoredScalarField(field, schema) && isOmitted(field));
+}
+export function getSortableFieldNames(model, schema) {
+    return getStoredFields(model, getModelNames(schema))
+        .filter((field) => isStoredScalarField(field, schema))
+        .map((field) => field.name);
+}
+export function toModelConstantPrefix(modelName) {
+    return modelName.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+}

package/dist/api-generator/utils/filter-operators.d.ts

@@ -0,0 +1,14 @@
+import type { Field, Schema, TypeExpr } from '../../schema-dsl/ast.js';
+export type FilterFieldKind = 'string' | 'enum' | 'numeric' | 'boolean' | 'timestamp' | 'json' | 'other';
+export type FilterOperator = 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'in';
+export interface FilterFieldMeta {
+    name: string;
+    kind: FilterFieldKind;
+    operators: FilterOperator[];
+    enumValues?: string[];
+}
+export declare function getFilterFieldKind(field: Field, schema: Schema): FilterFieldKind;
+export declare function getFilterOperators(kind: FilterFieldKind): FilterOperator[];
+export declare function buildFilterFieldMeta(field: Field, schema: Schema): FilterFieldMeta;
+export declare function queryParamKey(fieldName: string, operator: FilterOperator): string;
+export declare function toFilterZodType(type: TypeExpr, field: Field, schema: Schema, operator: FilterOperator, coerce?: boolean): string;

package/dist/api-generator/utils/filter-operators.js

@@ -0,0 +1,92 @@
+const STRING_TYPES = new Set(['UUID', 'VARCHAR', 'TEXT']);
+const NUMERIC_TYPES = new Set(['INTEGER', 'SERIAL', 'SMALLINT', 'DECIMAL']);
+export function getFilterFieldKind(field, schema) {
+    const typeName = field.type.name;
+    if (schema.enums.some((enumDef) => enumDef.name === typeName)) {
+        return 'enum';
+    }
+    if (STRING_TYPES.has(typeName)) {
+        return 'string';
+    }
+    if (NUMERIC_TYPES.has(typeName)) {
+        return 'numeric';
+    }
+    if (typeName === 'BOOLEAN') {
+        return 'boolean';
+    }
+    if (typeName === 'TIMESTAMP') {
+        return 'timestamp';
+    }
+    if (typeName === 'JSONB' || typeName === 'POINT' || (field.type.array && typeName === 'TEXT')) {
+        return 'json';
+    }
+    return 'other';
+}
+export function getFilterOperators(kind) {
+    switch (kind) {
+        case 'string':
+            return ['equals', 'contains', 'startsWith', 'endsWith'];
+        case 'enum':
+            return ['equals', 'in'];
+        case 'numeric':
+            return ['equals', 'gt', 'gte', 'lt', 'lte'];
+        case 'boolean':
+        case 'timestamp':
+        case 'json':
+        case 'other':
+            return ['equals'];
+    }
+}
+export function buildFilterFieldMeta(field, schema) {
+    const kind = getFilterFieldKind(field, schema);
+    const operators = getFilterOperators(kind);
+    const enumDef = schema.enums.find((entry) => entry.name === field.type.name);
+    return {
+        name: field.name,
+        kind,
+        operators,
+        ...(enumDef ? { enumValues: enumDef.values } : {}),
+    };
+}
+export function queryParamKey(fieldName, operator) {
+    if (operator === 'equals') {
+        return fieldName;
+    }
+    return `${fieldName}_${operator}`;
+}
+export function toFilterZodType(type, field, schema, operator, coerce = false) {
+    const prefix = coerce ? 'z.coerce.' : 'z.';
+    const enumType = schema.enums.find((enumDef) => enumDef.name === type.name);
+    if (enumType) {
+        if (operator === 'in') {
+            return `${prefix}string()`;
+        }
+        const values = enumType.values.map((value) => `'${value}'`).join(', ');
+        return `z.enum([${values}])`;
+    }
+    if (type.array && type.name === 'TEXT') {
+        return `${prefix}string()`;
+    }
+    switch (type.name) {
+        case 'UUID':
+        case 'VARCHAR':
+        case 'TEXT':
+            return `${prefix}string()`;
+        case 'INTEGER':
+        case 'SERIAL':
+        case 'SMALLINT':
+            return `${prefix}number().int()`;
+        case 'BOOLEAN':
+            return `${prefix}boolean()`;
+        case 'TIMESTAMP':
+            return 'z.coerce.date()';
+        case 'DECIMAL':
+            return `${prefix}string()`;
+        case 'JSONB':
+            return 'z.string()';
+        case 'POINT':
+            return 'z.string()';
+        default:
+            return 'z.string()';
+    }
+}

package/dist/api-generator/zod-schema-generator.d.ts

@@ -4,6 +4,8 @@ export declare class ZodSchemaGenerator {
     constructor(schema: Schema);
     generate(): string;
     private generateModelSchemas;
+    private generateListQuerySchemas;
+    private generateListQueryFieldLines;
     private generateObjectField;
     private generateParamField;
     private toParamZodType;

package/dist/api-generator/zod-schema-generator.js

@@ -1,14 +1,18 @@
 import { fieldHasAttribute, getFieldAttribute, getModelNames, getOptionalKvPair, getPrimaryKey, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
+import { getFilterableFields, getOmittedFields, getSortableFieldNames, toModelConstantPrefix, } from './utils/api-fields.js';
+import { buildFilterFieldMeta, queryParamKey, toFilterZodType, } from './utils/filter-operators.js';
 export class ZodSchemaGenerator {
     schema;
     constructor(schema) {
         this.schema = schema;
     }
     generate() {
+        const typeImports = this.schema.models.map((model) => model.name).join(',\n  ');
         const modelBlocks = this.schema.models.flatMap((model) => this.generateModelSchemas(model));
         return [
             '// Auto-generated by ZodSchemaGenerator. Do not edit manually.',
             "import { z } from 'zod';",
+            `import type {\n  ${typeImports},\n} from '../db-types.js';`,
             '',
             ...modelBlocks,
         ].join('\n');
@@ -35,8 +39,59 @@ export class ZodSchemaGenerator {
         if (paramLines.length > 0) {
             blocks.push(`export const ${model.name}ParamSchema = z.object({`, ...paramLines.map((line) => `  ${line},`), `});\n`);
         }
+        blocks.push(...this.generateListQuerySchemas(model));
         return blocks;
     }
+    generateListQuerySchemas(model) {
+        const prefix = toModelConstantPrefix(model.name);
+        const filterableFields = getFilterableFields(model, this.schema);
+        const sortableFields = getSortableFieldNames(model, this.schema);
+        const omittedFields = getOmittedFields(model, this.schema);
+        const filterFieldMeta = filterableFields.map((field) => buildFilterFieldMeta(field, this.schema));
+        const queryLines = filterableFields.flatMap((field) => this.generateListQueryFieldLines(field, filterFieldMeta.find((meta) => meta.name === field.name)));
+        queryLines.push('limit: z.coerce.number().int().min(1).max(100).optional(),', 'offset: z.coerce.number().int().min(0).optional(),', 'sort: z.string().optional(),');
+        const sortableLiteral = sortableFields.map((field) => `'${field}'`).join(', ');
+        const listQueryFieldsJson = JSON.stringify(filterFieldMeta, null, 2);
+        const omitFieldNames = omittedFields.map((field) => field.name);
+        const omitFieldsJson = JSON.stringify(omitFieldNames);
+        const responseType = omittedFields.length === 0
+            ? `export type ${model.name}Response = ${model.name};`
+            : `export type ${model.name}Response = Omit<${model.name}, ${omitFieldNames.map((name) => `'${name}'`).join(' | ')}>;`;
+        return [
+            `export const ${prefix}_SORTABLE_FIELDS = [${sortableLiteral}] as const;`,
+            `export const ${prefix}_LIST_QUERY_FIELDS = ${listQueryFieldsJson} as const;`,
+            `export const ${prefix}_OMIT_FIELDS = ${omitFieldsJson} as const;`,
+            responseType + '\n',
+            `export const ${model.name}ListQuerySchema = z`,
+            '  .object({',
+            ...queryLines.map((line) => `    ${line}`),
+            '  })',
+            '  .superRefine((data, ctx) => {',
+            '    if (data.sort === undefined) {',
+            '      return;',
+            '    }',
+            '    const descending = data.sort.startsWith(\'-\');',
+            '    const field = descending ? data.sort.slice(1) : data.sort;',
+            `    if (!(${prefix}_SORTABLE_FIELDS as readonly string[]).includes(field)) {`,
+            '      ctx.addIssue({',
+            '        code: \'custom\',',
+            '        message: `Invalid sort field "${field}"`,',
+            '        path: [\'sort\'],',
+            '      });',
+            '    }',
+            '  });\n',
+        ];
+    }
+    generateListQueryFieldLines(field, meta) {
+        const lines = [];
+        for (const operator of meta.operators) {
+            const key = queryParamKey(field.name, operator);
+            const useCoerce = operator !== 'equals' || field.type.name !== 'BOOLEAN';
+            const zodType = toFilterZodType(field.type, field, this.schema, operator, useCoerce);
+            lines.push(`${key}: ${zodType}.optional(),`);
+        }
+        return lines;
+    }
     generateObjectField(field, mode) {
         const zodType = this.toZodType(field, mode);
         const fieldName = `${field.name}: ${zodType}`;

package/dist/cli/init.js

@@ -3,10 +3,11 @@ import { PACKAGE_NAME } from '../constants.js';
 import { existsSync } from 'node:fs';
 import { mkdir, readdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { APP_SCHEMA_TEMPLATE, createPackageJsonTemplate, DOCKER_COMPOSE_TEMPLATE, ENV_TEMPLATE, HEALTH_ROUTE_TEMPLATE, TSCONFIG_TEMPLATE, } from './templates.js';
+import { APP_SCHEMA_TEMPLATE, createPackageJsonTemplate, DOCKER_COMPOSE_TEMPLATE, ENV_TEMPLATE, GITIGNORE_TEMPLATE, HEALTH_ROUTE_TEMPLATE, TSCONFIG_TEMPLATE, } from './templates.js';
 const INIT_FILES = [
     { relativePath: 'app.schema', content: APP_SCHEMA_TEMPLATE },
     { relativePath: '.env', content: ENV_TEMPLATE },
+    { relativePath: '.gitignore', content: GITIGNORE_TEMPLATE },
     { relativePath: 'docker-compose.yml', content: DOCKER_COMPOSE_TEMPLATE },
     { relativePath: 'tsconfig.json', content: TSCONFIG_TEMPLATE },
     { relativePath: 'src/routes/health.ts', content: HEALTH_ROUTE_TEMPLATE },
@@ -35,6 +36,23 @@ function runNpmInstall(cwd) {
         });
     });
 }
+function runGitInit(cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', ['init'], {
+            cwd,
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`git init failed with exit code ${code}`));
+        });
+    });
+}
 export async function runInit(args) {
     const skipInstall = args.includes('--skip-install');
     const targetDir = resolveTargetDir(args);
@@ -68,6 +86,14 @@ export async function runInit(args) {
         console.log('\nRunning npm install...');
         await runNpmInstall(targetDir);
     }
+    const gitDir = path.join(targetDir, '.git');
+    if (existsSync(gitDir)) {
+        console.log('\nSkipped git init (already a repository)');
+    }
+    else {
+        console.log('\nRunning git init...');
+        await runGitInit(targetDir);
+    }
     console.log('\nNext steps:');
     if (targetDir !== process.cwd()) {
         console.log(`  cd ${targetDir}`);

package/dist/cli/templates.d.ts

@@ -1,5 +1,6 @@
 export declare const APP_SCHEMA_TEMPLATE = "models {\n  model User {\n    id:        UUID        @id @default(gen_random_uuid())\n    email:     VARCHAR(255) @unique\n    name:      VARCHAR(150)\n    createdAt: TIMESTAMP   @default(now())\n  }\n}\n";
 export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\n";
+export declare const GITIGNORE_TEMPLATE = "node_modules/\ndist/\n.env\ndocker_data/\n.DS_Store\n*.log\nnpm-debug.log*\n";
 export declare const DOCKER_COMPOSE_TEMPLATE = "services:\n  postgres:\n    image: postgis/postgis:16-3.4\n    container_name: schematic-pg-postgres\n    restart: unless-stopped\n    ports:\n      - \"5432:5432\"\n    environment:\n      POSTGRES_USER: postgrest\n      POSTGRES_PASSWORD: postgrest\n      POSTGRES_DB: postgrest\n    volumes:\n      - ./docker_data/postgres:/var/lib/postgresql/data\n    healthcheck:\n      test: [\"CMD-SHELL\", \"pg_isready -U postgrest -d postgrest\"]\n      interval: 5s\n      timeout: 5s\n      retries: 5\n";
 export declare const TSCONFIG_TEMPLATE = "{\n  \"compilerOptions\": {\n    \"target\": \"ES2022\",\n    \"module\": \"NodeNext\",\n    \"moduleResolution\": \"NodeNext\",\n    \"strict\": true,\n    \"esModuleInterop\": true,\n    \"skipLibCheck\": true,\n    \"outDir\": \"dist\",\n    \"rootDir\": \".\"\n  },\n  \"include\": [\"generated/**/*\", \"src/**/*\"]\n}\n";
 export declare const HEALTH_ROUTE_TEMPLATE = "import { Hono } from 'hono';\nimport type { AppEnv } from 'schematic-pg/api/types';\n\nconst router = new Hono<AppEnv>();\nrouter.get('/', (c) => c.json({ ok: true }));\nexport default router;\n";

package/dist/cli/templates.js

@@ -1,4 +1,4 @@
-import { PACKAGE_NAME } from '../constants.js';
+import { PACKAGE_NAME, PACKAGE_VERSION } from '../constants.js';
 export const APP_SCHEMA_TEMPLATE = `models {
   model User {
     id:        UUID        @id @default(gen_random_uuid())
@@ -13,6 +13,14 @@ JWT_SECRET=
 JWT_ROLE_CLAIM=role
 JWT_USER_ID_CLAIM=sub
 `;
+export const GITIGNORE_TEMPLATE = `node_modules/
+dist/
+.env
+docker_data/
+.DS_Store
+*.log
+npm-debug.log*
+`;
 export const DOCKER_COMPOSE_TEMPLATE = `services:
   postgres:
     image: postgis/postgis:16-3.4
@@ -70,7 +78,7 @@ export function createPackageJsonTemplate(projectName) {
             '@hono/zod-validator': '^0.8.0',
             hono: '^4.12.27',
             pg: '^8.22.0',
-            [PACKAGE_NAME]: '^0.1.0',
+            [PACKAGE_NAME]: `^${PACKAGE_VERSION}`,
             zod: '^4.4.3',
         },
         devDependencies: {

package/dist/constants.d.ts

@@ -1 +1,3 @@
 export declare const PACKAGE_NAME = "schematic-pg";
+export declare const PACKAGE_VERSION: string;
+export declare const MAX_INCLUDE_DEPTH = 10;

package/dist/constants.js

@@ -1 +1,6 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 export const PACKAGE_NAME = 'schematic-pg';
+export const PACKAGE_VERSION = version;
+export const MAX_INCLUDE_DEPTH = 10;

package/dist/db/db-client-generator.js

@@ -14,9 +14,18 @@ export class DbClientGenerator {
             `${model.name}UpdateInput`,
             `${model.name}WhereInput`,
             `${model.name}OrderByInput`,
+            `${model.name}Include`,
         ])
             .join(',\n  ');
         const clientEntries = this.schema.models.map((model) => this.generateClientEntry(model.name));
+        const metaHydrations = this.schema.models.map((model) => {
+            const clientKey = getClientExportName(model.name);
+            return `  const ${clientKey}Meta = hydrateModelMeta(${clientKey}ModelMeta);`;
+        });
+        const registryEntries = this.schema.models.map((model) => {
+            const clientKey = getClientExportName(model.name);
+            return `    ['${model.name}', ${clientKey}Meta]`;
+        });
         return [
             '// Auto-generated by DbClientGenerator. Do not edit manually.',
             "import type { Pool } from 'pg';",
@@ -26,10 +35,10 @@ export class DbClientGenerator {
             `import {\n  ${this.schema.models.map((model) => `${getClientExportName(model.name)}ModelMeta`).join(',\n  ')},\n} from './db-model-meta.js';`,
             '',
             'export function createDbClient(pool: Pool) {',
-            ...this.schema.models.map((model) => {
-                const clientKey = getClientExportName(model.name);
-                return `  const ${clientKey}Meta = hydrateModelMeta(${clientKey}ModelMeta);`;
-            }),
+            ...metaHydrations,
+            `  const modelRegistry = new Map([`,
+            ...registryEntries.map((entry) => `    ${entry},`),
+            '  ]);',
             '',
             '  return {',
             clientEntries.map((entry) => `    ${entry},`).join('\n'),
@@ -56,7 +65,7 @@ export class DbClientGenerator {
     }
     generateClientEntry(modelName) {
         const clientKey = getClientExportName(modelName);
-        return `${clientKey}: createModelClient<${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput, ${modelName}WhereInput, ${modelName}OrderByInput>(${clientKey}Meta, pool)`;
+        return `${clientKey}: createModelClient<${modelName}, ${modelName}CreateInput, ${modelName}UpdateInput, ${modelName}WhereInput, ${modelName}OrderByInput>(${clientKey}Meta, pool, modelRegistry)`;
     }
 }
 export function generateDbClientFiles(schema) {

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

@@ -0,0 +1,3 @@
+import type { Pool } from 'pg';
+import type { LoadNode } from './planner.js';
+export declare function loadIncludes(parentRows: Record<string, unknown>[], plan: LoadNode, pool: Pool): Promise<void>;