schematic-pg 0.1.0

package/dist/api-generator/index.js

@@ -0,0 +1,15 @@
+import { generateAppFile } from './app-generator.js';
+import { generatePoliciesFile } from './policy-generator.js';
+import { generateRouteFiles } from './route-generator.js';
+import { generateValidationSchemas } from './zod-schema-generator.js';
+export function generateApiFiles(schema, options) {
+    const appOptions = options?.customRoutesDir
+        ? { customRoutesDir: options.customRoutesDir }
+        : undefined;
+    return {
+        app: generateAppFile(schema, appOptions),
+        policies: generatePoliciesFile(schema),
+        validation: generateValidationSchemas(schema),
+        routes: generateRouteFiles(schema),
+    };
+}

package/dist/api-generator/policy-generator.d.ts

@@ -0,0 +1,9 @@
+import type { Schema } from '../schema-dsl/ast.js';
+import { type NormalizedPolicy, type PolicyOperation } from './utils/policy.js';
+export declare class PolicyGenerator {
+    private readonly schema;
+    constructor(schema: Schema);
+    generate(): string;
+}
+export declare function generatePoliciesFile(schema: Schema): string;
+export type { NormalizedPolicy, PolicyOperation };

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

@@ -0,0 +1,33 @@
+import { hasPolicies, normalizePolicies, serializePolicy, } from './utils/policy.js';
+export class PolicyGenerator {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    generate() {
+        const modelsWithPolicies = this.schema.models.filter(hasPolicies);
+        const policyEntries = modelsWithPolicies.map((model) => {
+            const policies = normalizePolicies(model);
+            const serializedPolicies = policies.map((policy) => serializePolicy(policy)).join(',\n    ');
+            return `  ${model.name}: [\n    ${serializedPolicies},\n  ]`;
+        });
+        return [
+            '// Auto-generated by PolicyGenerator. Do not edit manually.',
+            "export type PolicyOperation = 'select' | 'insert' | 'update' | 'delete';",
+            '',
+            'export interface NormalizedPolicy {',
+            '  role: string;',
+            "  operations: PolicyOperation[] | 'all';",
+            '  where?: string;',
+            '}',
+            '',
+            'export const POLICIES: Record<string, NormalizedPolicy[]> = {',
+            policyEntries.join(',\n'),
+            '};',
+            '',
+        ].join('\n');
+    }
+}
+export function generatePoliciesFile(schema) {
+    return new PolicyGenerator(schema).generate();
+}

package/dist/api-generator/route-generator.d.ts

@@ -0,0 +1,20 @@
+import type { Model, Schema } from '../schema-dsl/ast.js';
+export declare class RouteGenerator {
+    private readonly model;
+    private readonly schema;
+    constructor(model: Model, schema: Schema);
+    generate(): string;
+    private generateListRoute;
+    private generateGetRoute;
+    private generateCreateRoute;
+    private generateUpdateRoute;
+    private generateDeleteRoute;
+    getRouteFileName(): string;
+    getRouteBasePath(): string;
+}
+export declare function generateRouteFiles(schema: Schema): Map<string, string>;
+export declare function getRouteMountEntries(schema: Schema): {
+    basePath: string;
+    fileName: string;
+    importName: string;
+}[];

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

@@ -0,0 +1,198 @@
+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 { hasPolicies } from './utils/policy.js';
+export class RouteGenerator {
+    model;
+    schema;
+    constructor(model, schema) {
+        this.model = model;
+        this.schema = schema;
+    }
+    generate() {
+        const clientKey = getClientExportName(this.model.name);
+        const primaryKey = getPrimaryKey(this.model);
+        if (!primaryKey) {
+            throw new Error(`Model ${this.model.name} has no primary key`);
+        }
+        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 modelHasPolicies = hasPolicies(this.model);
+        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 { notFoundResponse } from '${PACKAGE_NAME}/api/middleware/errors';`,
+            ...(modelHasPolicies
+                ? [
+                    `import { assertPolicy, mergeWhere, resolvePolicyWhere } from '${PACKAGE_NAME}/api/auth/policy';`,
+                ]
+                : []),
+            `import {`,
+            `  ${this.model.name}CreateSchema,`,
+            `  ${this.model.name}UpdateSchema,`,
+            `  ${paramSchemaName},`,
+            `} from '../schemas/validation.js';`,
+            '',
+            'const router = new Hono<AppEnv>();',
+            '',
+            ...this.generateListRoute(clientKey, modelHasPolicies),
+            '',
+            ...this.generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies),
+            '',
+            ...this.generateCreateRoute(clientKey, modelHasPolicies),
+            '',
+            ...this.generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies),
+            '',
+            ...this.generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies),
+            '',
+            'export default router;',
+            '',
+        ].join('\n');
+    }
+    generateListRoute(clientKey, modelHasPolicies) {
+        if (!modelHasPolicies) {
+            return [
+                "router.get('/', async (c) => {",
+                '  const db = c.get(\'db\');',
+                `  const rows = await db.${clientKey}.findMany();`,
+                '  return c.json(rows);',
+                '});',
+            ];
+        }
+        return [
+            "router.get('/', 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);',
+            '});',
+        ];
+    }
+    generateGetRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies) {
+        if (!modelHasPolicies) {
+            return [
+                `router.get('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
+                '  const db = c.get(\'db\');',
+                '  const params = c.req.valid(\'param\');',
+                `  const row = await db.${clientKey}.findUnique({ ${whereFromParams} });`,
+                '  if (!row) {',
+                '    return notFoundResponse(c);',
+                '  }',
+                '  return c.json(row);',
+                '});',
+            ];
+        }
+        return [
+            `router.get('/${pathParams}', validateParam(${paramSchemaName}), 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 params = c.req.valid(\'param\');',
+            `  const row = await db.${clientKey}.findUnique(mergeWhere({ ${whereFromParams} }, policyWhere));`,
+            '  if (!row) {',
+            '    return notFoundResponse(c);',
+            '  }',
+            '  return c.json(row);',
+            '});',
+        ];
+    }
+    generateCreateRoute(clientKey, modelHasPolicies) {
+        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 [
+            `router.post('/', validateJson(${this.model.name}CreateSchema), async (c) => {`,
+            '  const db = c.get(\'db\');',
+            '  const auth = c.get(\'auth\');',
+            `  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);',
+            '});',
+        ];
+    }
+    generateUpdateRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies) {
+        if (!modelHasPolicies) {
+            return [
+                `router.put('/${pathParams}', validateParam(${paramSchemaName}), validateJson(${this.model.name}UpdateSchema), async (c) => {`,
+                '  const db = c.get(\'db\');',
+                '  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 [
+            `router.put('/${pathParams}', validateParam(${paramSchemaName}), validateJson(${this.model.name}UpdateSchema), async (c) => {`,
+            '  const db = c.get(\'db\');',
+            '  const auth = c.get(\'auth\');',
+            `  const policy = assertPolicy('${this.model.name}', auth.role, 'update');`,
+            '  const policyWhere = resolvePolicyWhere(policy, auth);',
+            '  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);',
+            '});',
+        ];
+    }
+    generateDeleteRoute(clientKey, pathParams, paramSchemaName, whereFromParams, modelHasPolicies) {
+        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 [
+            `router.delete('/${pathParams}', validateParam(${paramSchemaName}), async (c) => {`,
+            '  const db = c.get(\'db\');',
+            '  const auth = c.get(\'auth\');',
+            `  const policy = assertPolicy('${this.model.name}', auth.role, 'delete');`,
+            '  const policyWhere = resolvePolicyWhere(policy, auth);',
+            '  const params = c.req.valid(\'param\');',
+            `  const row = await db.${clientKey}.delete(mergeWhere({ ${whereFromParams} }, policyWhere));`,
+            '  return c.json(row);',
+            '});',
+        ];
+    }
+    getRouteFileName() {
+        return toRouteFileName(this.model.name);
+    }
+    getRouteBasePath() {
+        return toRouteBasePath(this.model.name);
+    }
+}
+export function generateRouteFiles(schema) {
+    const files = new Map();
+    for (const model of schema.models) {
+        const generator = new RouteGenerator(model, schema);
+        files.set(generator.getRouteFileName(), generator.generate());
+    }
+    return files;
+}
+export function getRouteMountEntries(schema) {
+    return schema.models.map((model) => {
+        const basePath = toRouteBasePath(model.name);
+        const fileName = toRouteFileName(model.name);
+        const importName = toRouteImportName(basePath);
+        return { basePath, fileName, importName };
+    });
+}

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

@@ -0,0 +1,18 @@
+import type { Model } from '../../schema-dsl/ast.js';
+export declare const PUBLIC_ROLE = "PUBLIC";
+export type PolicyOperation = 'select' | 'insert' | 'update' | 'delete';
+export declare const POLICY_OPERATIONS: PolicyOperation[];
+export declare const OP_BY_METHOD: {
+    readonly GET: "select";
+    readonly POST: "insert";
+    readonly PUT: "update";
+    readonly DELETE: "delete";
+};
+export interface NormalizedPolicy {
+    role: string;
+    operations: PolicyOperation[] | 'all';
+    where?: string;
+}
+export declare function normalizePolicies(model: Model): NormalizedPolicy[];
+export declare function hasPolicies(model: Model): boolean;
+export declare function serializePolicy(policy: NormalizedPolicy): string;

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

@@ -0,0 +1,72 @@
+import { assertKeyValueArgs, getKvPair, getOptionalKvPair } from '../../sql-generator/utils/ast-helpers.js';
+export const PUBLIC_ROLE = 'PUBLIC';
+export const POLICY_OPERATIONS = ['select', 'insert', 'update', 'delete'];
+export const OP_BY_METHOD = {
+    GET: 'select',
+    POST: 'insert',
+    PUT: 'update',
+    DELETE: 'delete',
+};
+export function normalizePolicies(model) {
+    return model.attributes
+        .filter((attribute) => attribute.name === 'policy')
+        .map((attribute) => normalizePolicyAttribute(attribute));
+}
+export function hasPolicies(model) {
+    return model.attributes.some((attribute) => attribute.name === 'policy');
+}
+function normalizePolicyAttribute(attribute) {
+    const args = assertKeyValueArgs(attribute.args);
+    const role = parseIdentifierValue(getKvPair(args, 'role').value, 'role');
+    const allow = parseAllowOperations(getKvPair(args, 'allow').value);
+    const wherePair = getOptionalKvPair(args, 'where');
+    const policy = { role, operations: allow };
+    if (wherePair) {
+        policy.where = parseStringValue(wherePair.value, 'where');
+    }
+    return policy;
+}
+function parseAllowOperations(value) {
+    if (value.kind === 'Identifier') {
+        if (value.name === 'all') {
+            return 'all';
+        }
+        throw new Error(`Unknown policy allow value "${value.name}"`);
+    }
+    if (value.kind === 'ArrayLiteral') {
+        return value.elements.map((element) => parsePolicyOperation(element));
+    }
+    throw new Error('Policy allow must be "all" or an array of operations');
+}
+function parsePolicyOperation(value) {
+    if (value.kind !== 'Identifier') {
+        throw new Error('Policy operation must be an identifier');
+    }
+    const operation = value.name.toLowerCase();
+    if (!isPolicyOperation(operation)) {
+        throw new Error(`Unknown policy operation "${value.name}"`);
+    }
+    return operation;
+}
+function parseIdentifierValue(value, fieldName) {
+    if (value.kind !== 'Identifier') {
+        throw new Error(`Policy ${fieldName} must be an identifier`);
+    }
+    return value.name;
+}
+function parseStringValue(value, fieldName) {
+    if (value.kind !== 'StringLiteral') {
+        throw new Error(`Policy ${fieldName} must be a string`);
+    }
+    return value.value;
+}
+function isPolicyOperation(value) {
+    return POLICY_OPERATIONS.includes(value);
+}
+export function serializePolicy(policy) {
+    const operations = policy.operations === 'all'
+        ? "'all'"
+        : `[${policy.operations.map((operation) => `'${operation}'`).join(', ')}]`;
+    const where = policy.where ? `, where: ${JSON.stringify(policy.where)}` : '';
+    return `{ role: '${policy.role}', operations: ${operations}${where} }`;
+}

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

@@ -0,0 +1,16 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export declare class ZodSchemaGenerator {
+    private readonly schema;
+    constructor(schema: Schema);
+    generate(): string;
+    private generateModelSchemas;
+    private generateObjectField;
+    private generateParamField;
+    private toParamZodType;
+    private toZodType;
+    private mapBaseZodType;
+    private applyValidationRules;
+    private escapeRegexLiteral;
+    private escapeStringLiteral;
+}
+export declare function generateValidationSchemas(schema: Schema): string;

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

@@ -0,0 +1,145 @@
+import { fieldHasAttribute, getFieldAttribute, getModelNames, getOptionalKvPair, getPrimaryKey, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
+export class ZodSchemaGenerator {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    generate() {
+        const modelBlocks = this.schema.models.flatMap((model) => this.generateModelSchemas(model));
+        return [
+            '// Auto-generated by ZodSchemaGenerator. Do not edit manually.',
+            "import { z } from 'zod';",
+            '',
+            ...modelBlocks,
+        ].join('\n');
+    }
+    generateModelSchemas(model) {
+        const modelNames = getModelNames(this.schema);
+        const storedFields = getStoredFields(model, modelNames);
+        const primaryKey = getPrimaryKey(model);
+        const pkFields = new Set(primaryKey?.fields ?? []);
+        const createFields = storedFields.filter((field) => !pkFields.has(field.name));
+        const updateFields = storedFields.filter((field) => !pkFields.has(field.name));
+        const pkFieldDefs = storedFields.filter((field) => pkFields.has(field.name));
+        const createLines = createFields.map((field) => this.generateObjectField(field, 'create'));
+        const updateLines = updateFields.map((field) => this.generateObjectField(field, 'update'));
+        const paramLines = pkFieldDefs.map((field) => this.generateParamField(field));
+        const blocks = [
+            `export const ${model.name}CreateSchema = z.object({`,
+            ...createLines.map((line) => `  ${line},`),
+            `});\n`,
+            `export const ${model.name}UpdateSchema = z.object({`,
+            ...updateLines.map((line) => `  ${line},`),
+            `});\n`,
+        ];
+        if (paramLines.length > 0) {
+            blocks.push(`export const ${model.name}ParamSchema = z.object({`, ...paramLines.map((line) => `  ${line},`), `});\n`);
+        }
+        return blocks;
+    }
+    generateObjectField(field, mode) {
+        const zodType = this.toZodType(field, mode);
+        const fieldName = `${field.name}: ${zodType}`;
+        if (mode === 'update') {
+            return fieldName;
+        }
+        const isOptional = field.type.optional || fieldHasAttribute(field, 'default');
+        if (isOptional) {
+            return `${field.name}: ${zodType}.optional()`;
+        }
+        return fieldName;
+    }
+    generateParamField(field) {
+        const zodType = this.toParamZodType(field);
+        return `${field.name}: ${zodType}`;
+    }
+    toParamZodType(field) {
+        switch (field.type.name) {
+            case 'UUID':
+                return 'z.string().uuid()';
+            case 'INTEGER':
+            case 'SERIAL':
+            case 'SMALLINT':
+                return 'z.coerce.number().int()';
+            default:
+                return 'z.string()';
+        }
+    }
+    toZodType(field, mode) {
+        let zodType = this.mapBaseZodType(field.type, field);
+        zodType = this.applyValidationRules(field, zodType);
+        if (field.type.optional) {
+            zodType = `${zodType}.nullable()`;
+        }
+        if (mode === 'update') {
+            zodType = `${zodType}.optional()`;
+        }
+        return zodType;
+    }
+    mapBaseZodType(type, field) {
+        const enumType = this.schema.enums.find((enumDef) => enumDef.name === type.name);
+        if (enumType) {
+            const values = enumType.values.map((value) => `'${value}'`).join(', ');
+            return `z.enum([${values}])`;
+        }
+        if (type.array && type.name === 'TEXT') {
+            return 'z.array(z.string())';
+        }
+        switch (type.name) {
+            case 'UUID':
+            case 'VARCHAR':
+            case 'TEXT':
+                return 'z.string()';
+            case 'INTEGER':
+            case 'SERIAL':
+            case 'SMALLINT':
+                return 'z.number().int()';
+            case 'BOOLEAN':
+                return 'z.boolean()';
+            case 'TIMESTAMP':
+                return 'z.coerce.date()';
+            case 'DECIMAL':
+                return 'z.string()';
+            case 'JSONB':
+                return 'z.record(z.unknown())';
+            case 'POINT':
+                return 'z.unknown()';
+            default:
+                return 'z.unknown()';
+        }
+    }
+    applyValidationRules(field, zodType) {
+        const regexAttr = getFieldAttribute(field, 'regex');
+        if (regexAttr?.args?.kind === 'KeyValueArgs') {
+            const pattern = getOptionalKvPair(regexAttr.args, 'pattern');
+            const message = getOptionalKvPair(regexAttr.args, 'message');
+            if (pattern?.value.kind === 'StringLiteral' && message?.value.kind === 'StringLiteral') {
+                const escapedPattern = this.escapeRegexLiteral(pattern.value.value);
+                const escapedMessage = this.escapeStringLiteral(message.value.value);
+                zodType = `${zodType}.regex(/${escapedPattern}/, { message: '${escapedMessage}' })`;
+            }
+        }
+        const rangeAttr = getFieldAttribute(field, 'range');
+        if (rangeAttr?.args?.kind === 'KeyValueArgs') {
+            const min = getOptionalKvPair(rangeAttr.args, 'min');
+            const max = getOptionalKvPair(rangeAttr.args, 'max');
+            const message = getOptionalKvPair(rangeAttr.args, 'message');
+            if (min?.value.kind === 'NumberLiteral' &&
+                max?.value.kind === 'NumberLiteral' &&
+                message?.value.kind === 'StringLiteral') {
+                const escapedMessage = this.escapeStringLiteral(message.value.value);
+                zodType = `${zodType}.min(${min.value.value}, { message: '${escapedMessage}' }).max(${max.value.value}, { message: '${escapedMessage}' })`;
+            }
+        }
+        return zodType;
+    }
+    escapeRegexLiteral(pattern) {
+        return pattern.replace(/\//g, '\\/');
+    }
+    escapeStringLiteral(value) {
+        return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    }
+}
+export function generateValidationSchemas(schema) {
+    return new ZodSchemaGenerator(schema).generate();
+}

package/dist/cli/db.d.ts

@@ -0,0 +1,4 @@
+export declare function runDbPing(): Promise<void>;
+export declare function runDbBootstrap(schemaPath?: string): Promise<void>;
+export declare function runDbDiff(args: string[]): Promise<void>;
+export declare function runDbMigrate(args: string[]): Promise<void>;