schematic-pg 0.1.17 → 0.1.19

package/README.md

@@ -11,7 +11,7 @@
 
 `app.schema` is the source of truth. From it, schematic-pg generates PostgreSQL DDL, a type-safe DB client, REST routes, Zod validators, and ACL policies.
 
-A schema file always has three sections, in this order: `extensions`, `enums`, `models`.
+A schema file has three required sections, in this order: `extensions`, `enums`, `models`. An optional `functions` section may follow.
 
 ```ts
 extensions {
@@ -376,6 +376,52 @@ model User {
 | `level` | `ROW`, `STATEMENT` | `ROW` |
 | `execute` | Triple-quoted PL/pgSQL | — |
 
+### Functions
+
+Optional section after `models`. Each `function` becomes a PostgreSQL `CREATE OR REPLACE FUNCTION`. Names and parameters are converted to `snake_case` (`getUserBalance` → `get_user_balance`, `userId` → `user_id`). The `execute` body is copied as-is — use those SQL names inside it, not camelCase.
+
+```ts
+functions {
+  function getUserBalance(userId: UUID): INTEGER {
+    language: sql
+    volatility: STABLE
+    execute: """
+      SELECT balance FROM "user" WHERE id = user_id
+    """
+  }
+
+  function setUpdatedAt(): TRIGGER {
+    language: plpgsql
+    execute: """
+      NEW.updated_at = now();
+      RETURN NEW;
+    """
+  }
+}
+```
+
+| Argument | Values | Default |
+|----------|--------|---------|
+| `language` | `sql`, `plpgsql` | `sql` |
+| `volatility` | `VOLATILE`, `STABLE`, `IMMUTABLE` | `VOLATILE` |
+| `security` | `INVOKER`, `DEFINER` | `INVOKER` |
+| `execute` | Triple-quoted SQL / PL/pgSQL | required |
+
+Return types are PostgreSQL types (`INTEGER`, `UUID`, `JSONB`, …), `TRIGGER`, or `VOID`. Body keys may be newline-separated or comma-separated.
+
+`language: plpgsql` wraps the body in `BEGIN` / `END` unless it already starts with `DECLARE` or `BEGIN`. Function names must be unique in the schema.
+
+`db:diff` treats body, language, volatility, and security changes as `CREATE OR REPLACE`. Argument or return-type changes drop the old function, then create the new one.
+
+Functions are database objects only in this release — they are not REST endpoints. Call them with `db.$queryRaw`:
+
+```ts
+const [row] = await db.$queryRaw<{ get_user_balance: number }>(
+  'SELECT get_user_balance($1)',
+  [userId],
+);
+```
+
 ---
 
 ## Quick Start
@@ -456,11 +502,12 @@ Generated code imports the runtime from the `schematic-pg` package (`schematic-p
 | `AUTH_ACCESS_TOKEN_TTL` | `1h` | Access token lifetime (`15m`, `1h`, or seconds) |
 | `JWT_ROLE_CLAIM` | `role` | JWT claim mapped to `auth.role` |
 | `JWT_USER_ID_CLAIM` | `sub` | JWT claim mapped to `auth.user.id` |
-| `CORS_ORIGIN` | — (disabled) | Allowed browser origins. Unset disables CORS. Use `*` for any origin, or a comma-separated list (`http://localhost:5173,https://app.example.com`) |
+| `CORS_ORIGIN` | — (disabled) | Allowed browser origins. Unset disables CORS. Use `*` for any origin (no cookies), or a comma-separated list (`http://localhost:5173,https://app.example.com`). Concrete origins enable credentialed CORS |
+| `CORS_ALLOW_HEADERS` | — | Extra allowed request headers (comma-separated), merged with `Authorization`, `Content-Type`, `X-CSRF-Token` |
 
 Set these in `.env` before running `dev`, `start`, or `db:bootstrap`.
 
-Browser frontends on another origin need `CORS_ORIGIN`. The generated app reads it at runtime (no regenerate). Preflight `OPTIONS` is handled automatically; `Authorization` and `Content-Type` are allowed. See [CORS](docs/rest-api.md#cors).
+Browser frontends on another origin need `CORS_ORIGIN`. The generated app reads it at runtime (no regenerate). Preflight `OPTIONS` is handled automatically; concrete origins enable cookies via `credentials: 'include'`. See [CORS](docs/rest-api.md#cors).
 
 ---
 

package/dist/api/middleware/cors.d.ts

@@ -1,6 +1,9 @@
 import type { MiddlewareHandler } from 'hono';
 import type { AppEnv } from '../types.js';
 export declare function parseCorsOrigin(raw?: string | undefined): string | string[] | null;
+/** Extra headers from `CORS_ALLOW_HEADERS` (comma-separated). Does not include defaults. */
+export declare function parseCorsAllowHeaders(raw?: string | undefined): string[];
 export declare function createCorsMiddleware(options?: {
     origin?: string | string[] | null;
+    allowHeaders?: string[];
 }): MiddlewareHandler<AppEnv>;

package/dist/api/middleware/cors.js

@@ -1,7 +1,17 @@
 import { cors } from 'hono/cors';
-const CORS_ALLOW_HEADERS = ['Authorization', 'Content-Type'];
+const DEFAULT_CORS_ALLOW_HEADERS = ['Authorization', 'Content-Type', 'X-CSRF-Token'];
 const CORS_ALLOW_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'];
 const CORS_MAX_AGE_SECONDS = 86400;
+function parseCommaSeparatedList(raw) {
+    const trimmed = raw?.trim() ?? '';
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
 export function parseCorsOrigin(raw = process.env.CORS_ORIGIN) {
     const trimmed = raw?.trim() ?? '';
     if (!trimmed) {
@@ -10,15 +20,36 @@ export function parseCorsOrigin(raw = process.env.CORS_ORIGIN) {
     if (trimmed === '*') {
         return '*';
     }
-    const origins = trimmed
-        .split(',')
-        .map((origin) => origin.trim())
-        .filter((origin) => origin.length > 0);
+    const origins = parseCommaSeparatedList(trimmed);
     if (origins.length === 0) {
         return null;
     }
     return origins.length === 1 ? origins[0] : origins;
 }
+/** Extra headers from `CORS_ALLOW_HEADERS` (comma-separated). Does not include defaults. */
+export function parseCorsAllowHeaders(raw = process.env.CORS_ALLOW_HEADERS) {
+    return parseCommaSeparatedList(raw);
+}
+function resolveAllowHeaders(optionsAllowHeaders) {
+    if (optionsAllowHeaders !== undefined) {
+        return optionsAllowHeaders;
+    }
+    const extras = parseCorsAllowHeaders();
+    if (extras.length === 0) {
+        return DEFAULT_CORS_ALLOW_HEADERS;
+    }
+    const seen = new Set(DEFAULT_CORS_ALLOW_HEADERS.map((header) => header.toLowerCase()));
+    const merged = [...DEFAULT_CORS_ALLOW_HEADERS];
+    for (const header of extras) {
+        const key = header.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        merged.push(header);
+    }
+    return merged;
+}
 export function createCorsMiddleware(options = {}) {
     const origin = options.origin !== undefined ? options.origin : parseCorsOrigin();
     if (origin == null) {
@@ -26,9 +57,12 @@ export function createCorsMiddleware(options = {}) {
             await next();
         };
     }
+    const allowHeaders = resolveAllowHeaders(options.allowHeaders);
+    const credentials = origin !== '*';
     return cors({
         origin,
-        allowHeaders: CORS_ALLOW_HEADERS,
+        credentials,
+        allowHeaders,
         allowMethods: CORS_ALLOW_METHODS,
         maxAge: CORS_MAX_AGE_SECONDS,
     });

package/dist/cli/templates/agents.md

@@ -14,7 +14,7 @@ schematic-pg is a single-file backend framework for PostgreSQL and Node.js. **`a
 
 1. **Never edit `generated/`** — it is overwritten on every `generate` / `dev` run.
 2. **Regenerate after changes** to `app.schema`, `src/routes/`, or `src/hooks/` (`schematic-pg generate` or `schematic-pg dev`).
-3. **Edit `app.schema`** for models, relations, policies, indexes, and triggers.
+3. **Edit `app.schema`** for models, relations, policies, indexes, triggers, and SQL functions.
 4. **Use extension points** for app-specific logic: `src/routes/` (custom HTTP) and `src/hooks/` (lifecycle hooks).
 5. **Do not hand-write SQL** for CRUD — use the generated DB client or REST API.
 
@@ -59,7 +59,8 @@ npx schematic-pg dev
 | `JWT_SECRET` | HMAC secret for Bearer JWT auth |
 | `JWT_ROLE_CLAIM` | JWT claim for role (default `role`) |
 | `JWT_USER_ID_CLAIM` | JWT claim for user id (default `sub`) |
-| `CORS_ORIGIN` | Allowed browser origins (`*` or comma-separated). Unset disables CORS |
+| `CORS_ORIGIN` | Allowed browser origins (`*` or comma-separated). Unset disables CORS. Concrete origins enable credentialed CORS (cookies); `*` does not |
+| `CORS_ALLOW_HEADERS` | Extra allowed request headers (comma-separated), merged with Authorization, Content-Type, X-CSRF-Token |
 
 ## Schema DSL Essentials
 
@@ -99,6 +100,7 @@ models {
 - **Policies:** `@policy(role: ..., allow: [select|insert|update|delete|all], where: "...")` — `where` supports `{{auth.user.id}}`.
 - **Validation:** `@regex(...)`, `@range(min: ..., max: ...)` flow into generated Zod schemas.
 - **Indexes / triggers:** `@@index(...)`, `@@trigger { timing, event, level, execute: """...""" }`.
+- **SQL functions:** optional `functions { function name(args): ReturnType { execute: """...""" } }` after `models`. Names snake_case in SQL; call with `db.$queryRaw`.
 
 ## Database Client
 

package/dist/cli/templates.d.ts

@@ -1,6 +1,6 @@
 export declare const AGENTS_TEMPLATE: string;
 export declare const APP_SCHEMA_TEMPLATE = "extensions {\n\n}\n\nenums {\n  UserRole { ADMIN, USER }\n}\n\nmodels {\n  model User {\n    id:           UUID         @id @default(gen_random_uuid())\n    email:        VARCHAR(255) @unique @regex(pattern: \"^[\\w.-]+@[\\w.-]+\\.\\w+$\", message: \"Invalid email address\")\n    name:         VARCHAR(150)?\n    role:         UserRole     @default(USER)\n    passwordHash: VARCHAR(255)? @omit @unfilterable\n    createdAt:    TIMESTAMP    @default(now())\n\n    @rest(except: [create, update, delete])\n    @policy(role: USER, allow: [select], where: \"id = {{auth.user.id}}\")\n    @policy(role: ADMIN, allow: all)\n  }\n}\n";
-export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nAUTH_PEPPER=\nAUTH_ACCESS_TOKEN_TTL=1h\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\nCORS_ORIGIN=\n";
+export declare const ENV_TEMPLATE = "DATABASE_URL=postgresql://postgrest:postgrest@localhost:5432/postgrest\nJWT_SECRET=\nAUTH_PEPPER=\nAUTH_ACCESS_TOKEN_TTL=1h\nJWT_ROLE_CLAIM=role\nJWT_USER_ID_CLAIM=sub\nCORS_ORIGIN=\nCORS_ALLOW_HEADERS=\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: postgres:18.4-bookworm\n    container_name: schematic-pg\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\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";

package/dist/cli/templates.js

@@ -34,6 +34,7 @@ AUTH_ACCESS_TOKEN_TTL=1h
 JWT_ROLE_CLAIM=role
 JWT_USER_ID_CLAIM=sub
 CORS_ORIGIN=
+CORS_ALLOW_HEADERS=
 `;
 export const GITIGNORE_TEMPLATE = `node_modules/
 dist/

package/dist/schema-dsl/ast.d.ts

@@ -9,6 +9,7 @@ export interface Schema {
     extensions: Extension[];
     enums: Enum[];
     models: Model[];
+    functions: SqlFunction[];
     loc: SourceLocation;
 }
 export interface Extension {
@@ -31,6 +32,23 @@ export interface Model {
     directives: Directive[];
     loc: SourceLocation;
 }
+export interface SqlFunction {
+    kind: 'SqlFunction';
+    name: string;
+    params: FunctionParam[];
+    returns: TypeExpr;
+    language?: string;
+    volatility?: string;
+    security?: string;
+    execute: string;
+    loc: SourceLocation;
+}
+export interface FunctionParam {
+    kind: 'FunctionParam';
+    name: string;
+    type: TypeExpr;
+    loc: SourceLocation;
+}
 export interface Field {
     kind: 'Field';
     name: string;

package/dist/schema-dsl/lexer.js

@@ -130,7 +130,10 @@ export class Lexer {
     scanTripleString(startLine, startCol) {
         let value = '';
         while (!this.isAtEnd()) {
-            if (this.match('"') && this.match('"') && this.match('"')) {
+            if (this.peekChar() === '"' && this.peekChar(1) === '"' && this.peekChar(2) === '"') {
+                this.advance();
+                this.advance();
+                this.advance();
                 return this.makeToken(TokenType.TRIPLE_STRING, value, startLine, startCol);
             }
             value += this.advance();

package/dist/schema-dsl/parser.d.ts

@@ -1,4 +1,4 @@
-import type { Attribute, Field, Model, Schema } from './ast.js';
+import type { Attribute, Field, Model, Schema, SqlFunction } from './ast.js';
 import { Token } from './tokens.js';
 export declare class ParseError extends Error {
     readonly line: number;
@@ -20,6 +20,11 @@ export declare class Parser {
     private parseEnumsSection;
     private parseEnum;
     private parseModelsSection;
+    private parseFunctionsSection;
+    parseFunction(existingNames?: Set<string>): SqlFunction;
+    private parseFunctionParams;
+    private parseFunctionParam;
+    private parseFunctionBody;
     private parseModelBody;
     private parseTypeExpr;
     private parseFieldAttributes;

package/dist/schema-dsl/parser.js

@@ -24,12 +24,14 @@ export class Parser {
         const extensions = this.parseExtensionsSection();
         const enums = this.parseEnumsSection();
         const models = this.parseModelsSection();
+        const functions = this.check(TokenType.FUNCTIONS) ? this.parseFunctionsSection() : [];
         this.expect(TokenType.EOF, 'end of schema');
         return {
             kind: 'Schema',
             extensions,
             enums,
             models,
+            functions,
             loc: this.loc(start),
         };
     }
@@ -113,6 +115,135 @@ export class Parser {
         this.expect(TokenType.RBRACE, "'}'");
         return models;
     }
+    parseFunctionsSection() {
+        this.expect(TokenType.FUNCTIONS, "'functions'");
+        this.expect(TokenType.LBRACE, "'{'");
+        const functions = [];
+        const names = new Set();
+        while (!this.check(TokenType.RBRACE)) {
+            functions.push(this.parseFunction(names));
+        }
+        this.expect(TokenType.RBRACE, "'}'");
+        return functions;
+    }
+    parseFunction(existingNames) {
+        const start = this.expect(TokenType.FUNCTION, "'function'");
+        const nameToken = this.expect(TokenType.IDENT, 'function name');
+        if (existingNames?.has(nameToken.value)) {
+            throw new ParseError(`unique function name, "${nameToken.value}" already defined`, nameToken);
+        }
+        existingNames?.add(nameToken.value);
+        this.expect(TokenType.LPAREN, "'('");
+        const params = this.parseFunctionParams();
+        this.expect(TokenType.RPAREN, "')'");
+        this.expect(TokenType.COLON, "':'");
+        const returns = this.parseTypeExpr();
+        this.expect(TokenType.LBRACE, "'{'");
+        const body = this.parseFunctionBody();
+        this.expect(TokenType.RBRACE, "'}'");
+        return {
+            kind: 'SqlFunction',
+            name: nameToken.value,
+            params,
+            returns,
+            language: body.language,
+            volatility: body.volatility,
+            security: body.security,
+            execute: body.execute,
+            loc: this.loc(start),
+        };
+    }
+    parseFunctionParams() {
+        if (this.check(TokenType.RPAREN)) {
+            return [];
+        }
+        const params = [];
+        do {
+            params.push(this.parseFunctionParam());
+        } while (this.match(TokenType.COMMA) && !this.check(TokenType.RPAREN));
+        this.consumeTrailingComma();
+        return params;
+    }
+    parseFunctionParam() {
+        const start = this.expect(TokenType.IDENT, 'parameter name');
+        this.expect(TokenType.COLON, "':'");
+        const type = this.parseTypeExpr();
+        return {
+            kind: 'FunctionParam',
+            name: start.value,
+            type,
+            loc: this.loc(start),
+        };
+    }
+    parseFunctionBody() {
+        if (this.check(TokenType.RBRACE)) {
+            throw new ParseError("function body key 'execute'", this.current());
+        }
+        let language;
+        let volatility;
+        let security;
+        let execute;
+        do {
+            const keyToken = this.expect(TokenType.IDENT, 'function body key');
+            this.expect(TokenType.COLON, "':'");
+            const valueToken = this.current();
+            const value = this.parseValue();
+            switch (keyToken.value) {
+                case 'language': {
+                    if (value.kind !== 'Identifier') {
+                        throw new ParseError("'sql' or 'plpgsql'", valueToken);
+                    }
+                    const languageName = value.name.toLowerCase();
+                    if (languageName !== 'sql' && languageName !== 'plpgsql') {
+                        throw new ParseError("'sql' or 'plpgsql'", valueToken);
+                    }
+                    language = languageName;
+                    break;
+                }
+                case 'volatility': {
+                    if (value.kind !== 'Identifier') {
+                        throw new ParseError("'VOLATILE', 'STABLE', or 'IMMUTABLE'", valueToken);
+                    }
+                    const volatilityName = value.name.toUpperCase();
+                    if (volatilityName !== 'VOLATILE' &&
+                        volatilityName !== 'STABLE' &&
+                        volatilityName !== 'IMMUTABLE') {
+                        throw new ParseError("'VOLATILE', 'STABLE', or 'IMMUTABLE'", valueToken);
+                    }
+                    volatility = volatilityName;
+                    break;
+                }
+                case 'security': {
+                    if (value.kind !== 'Identifier') {
+                        throw new ParseError("'INVOKER' or 'DEFINER'", valueToken);
+                    }
+                    const securityName = value.name.toUpperCase();
+                    if (securityName !== 'INVOKER' && securityName !== 'DEFINER') {
+                        throw new ParseError("'INVOKER' or 'DEFINER'", valueToken);
+                    }
+                    security = securityName;
+                    break;
+                }
+                case 'execute': {
+                    if (value.kind !== 'TripleStringLiteral') {
+                        throw new ParseError('triple-quoted execute body', valueToken);
+                    }
+                    execute = value.value.trim();
+                    if (execute.length === 0) {
+                        throw new ParseError('non-empty execute body', valueToken);
+                    }
+                    break;
+                }
+                default:
+                    throw new ParseError("function body key 'language', 'volatility', 'security', or 'execute'", keyToken);
+            }
+            this.match(TokenType.COMMA);
+        } while (!this.check(TokenType.RBRACE));
+        if (!execute) {
+            throw new ParseError("function body key 'execute'", this.current());
+        }
+        return { language, volatility, security, execute };
+    }
     parseModelBody(name, start) {
         const fields = [];
         const attributes = [];

package/dist/schema-dsl/tokens.d.ts

@@ -3,6 +3,8 @@ export declare enum TokenType {
     ENUMS = "ENUMS",
     MODELS = "MODELS",
     MODEL = "MODEL",
+    FUNCTIONS = "FUNCTIONS",
+    FUNCTION = "FUNCTION",
     STRING = "STRING",
     TRIPLE_STRING = "TRIPLE_STRING",
     NUMBER = "NUMBER",

package/dist/schema-dsl/tokens.js

@@ -4,6 +4,8 @@ export var TokenType;
     TokenType["ENUMS"] = "ENUMS";
     TokenType["MODELS"] = "MODELS";
     TokenType["MODEL"] = "MODEL";
+    TokenType["FUNCTIONS"] = "FUNCTIONS";
+    TokenType["FUNCTION"] = "FUNCTION";
     TokenType["STRING"] = "STRING";
     TokenType["TRIPLE_STRING"] = "TRIPLE_STRING";
     TokenType["NUMBER"] = "NUMBER";
@@ -27,6 +29,8 @@ const KEYWORDS = {
     enums: TokenType.ENUMS,
     models: TokenType.MODELS,
     model: TokenType.MODEL,
+    functions: TokenType.FUNCTIONS,
+    function: TokenType.FUNCTION,
     true: TokenType.BOOLEAN,
     false: TokenType.BOOLEAN,
 };

package/dist/sql-generator/generators/functions.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from '../../schema-dsl/ast.js';
+import { type NormalizedFunction } from '../utils/ast-helpers.js';
+export type { NormalizedFunction };
+export declare function generateCreateFunction(normalized: NormalizedFunction): string;
+export declare function generateDropFunction(normalized: NormalizedFunction): string;
+export declare function generateFunctions(schema: Schema): string;

package/dist/sql-generator/generators/functions.js

@@ -0,0 +1,50 @@
+import { getEnumNames, normalizeFunction, } from '../utils/ast-helpers.js';
+import { joinSection } from '../utils/format.js';
+import { quoteIdentifier } from '../utils/snake-case.js';
+export function generateCreateFunction(normalized) {
+    const functionName = quoteIdentifier(normalized.sqlName);
+    const params = normalized.params
+        .map((param) => `${quoteIdentifier(param.sqlName)} ${param.sqlType}`)
+        .join(', ');
+    const clauses = [
+        `CREATE OR REPLACE FUNCTION ${functionName}(${params})`,
+        `RETURNS ${normalized.returns}`,
+        `LANGUAGE ${normalized.language}`,
+    ];
+    if (normalized.volatility !== 'VOLATILE') {
+        clauses.push(normalized.volatility);
+    }
+    if (normalized.security === 'DEFINER') {
+        clauses.push('SECURITY DEFINER');
+    }
+    const body = formatFunctionBody(normalized.execute, normalized.language);
+    clauses.push(`AS $$\n${body}\n$$;`);
+    return clauses.join('\n');
+}
+export function generateDropFunction(normalized) {
+    const functionName = quoteIdentifier(normalized.sqlName);
+    const argTypes = normalized.params.map((param) => param.sqlType).join(', ');
+    return `DROP FUNCTION IF EXISTS ${functionName}(${argTypes});`;
+}
+export function generateFunctions(schema) {
+    const enumNames = getEnumNames(schema);
+    const statements = schema.functions.map((sqlFunction) => generateCreateFunction(normalizeFunction(sqlFunction, enumNames)));
+    return joinSection('Create functions', statements);
+}
+function formatFunctionBody(execute, language) {
+    const trimmed = execute.trim();
+    const indented = indentBody(trimmed);
+    if (language !== 'plpgsql') {
+        return indented;
+    }
+    if (/^(declare|begin)\b/i.test(trimmed)) {
+        return indented;
+    }
+    return `BEGIN\n${indented}\nEND;`;
+}
+function indentBody(body) {
+    return body
+        .split('\n')
+        .map((line) => (line.length > 0 ? `  ${line}` : line))
+        .join('\n');
+}

package/dist/sql-generator/migration-planner.d.ts

@@ -9,6 +9,7 @@ export declare class MigrationPlanner {
     private diffConstraints;
     private diffIndexes;
     private diffTriggers;
+    private diffFunctions;
     private triggerSignatures;
     private indexSignatures;
 }

package/dist/sql-generator/migration-planner.js

@@ -1,4 +1,4 @@
-import { collectForeignKeys, getDirectives, getEnumNames, getModelNames, getStoredFields, isStoredField, normalizeIndexDirective, normalizeTriggerDirective, serializeColumnType, serializeDefault, serializeForeignKey, } from './utils/ast-helpers.js';
+import { collectForeignKeys, functionIdentity, functionSignature, getDirectives, getEnumNames, getModelNames, getStoredFields, isStoredField, normalizeFunction, normalizeIndexDirective, normalizeTriggerDirective, serializeColumnType, serializeDefault, serializeForeignKey, } from './utils/ast-helpers.js';
 export class MigrationPlanner {
     generateMigration(oldSchema, newSchema) {
         const migrations = [];
@@ -7,6 +7,7 @@ export class MigrationPlanner {
         migrations.push(...this.diffModels(oldSchema, newSchema));
         migrations.push(...this.diffConstraints(oldSchema, newSchema));
         migrations.push(...this.diffIndexes(oldSchema, newSchema));
+        migrations.push(...this.diffFunctions(oldSchema, newSchema));
         migrations.push(...this.diffTriggers(oldSchema, newSchema));
         return migrations;
     }
@@ -195,6 +196,48 @@ export class MigrationPlanner {
         }
         return migrations;
     }
+    diffFunctions(oldSchema, newSchema) {
+        const migrations = [];
+        const oldEnumNames = getEnumNames(oldSchema);
+        const newEnumNames = getEnumNames(newSchema);
+        const oldFunctions = new Map(oldSchema.functions.map((sqlFunction) => [
+            sqlFunction.name,
+            normalizeFunction(sqlFunction, oldEnumNames),
+        ]));
+        const newFunctions = new Map(newSchema.functions.map((sqlFunction) => [
+            sqlFunction.name,
+            normalizeFunction(sqlFunction, newEnumNames),
+        ]));
+        for (const [functionName, newFunction] of newFunctions) {
+            const oldFunction = oldFunctions.get(functionName);
+            if (!oldFunction) {
+                migrations.push({ kind: 'CreateFunction', functionName });
+                continue;
+            }
+            if (functionIdentity(oldFunction) !== functionIdentity(newFunction)) {
+                migrations.push({
+                    kind: 'DropFunction',
+                    functionName,
+                    signature: functionSignature(oldFunction),
+                });
+                migrations.push({ kind: 'CreateFunction', functionName });
+                continue;
+            }
+            if (functionSignature(oldFunction) !== functionSignature(newFunction)) {
+                migrations.push({ kind: 'ReplaceFunction', functionName });
+            }
+        }
+        for (const [functionName, oldFunction] of oldFunctions) {
+            if (!newFunctions.has(functionName)) {
+                migrations.push({
+                    kind: 'DropFunction',
+                    functionName,
+                    signature: functionSignature(oldFunction),
+                });
+            }
+        }
+        return migrations;
+    }
     triggerSignatures(model) {
         return new Set(getDirectives(model, 'trigger').map((directive) => JSON.stringify(normalizeTriggerDirective(directive))));
     }

package/dist/sql-generator/migration-sql-generator.js

@@ -1,10 +1,11 @@
 import { generateAddEnumValue, generateEnum } from './generators/enums.js';
 import { generateCreateExtension, generateDropExtension } from './generators/extensions.js';
 import { generateForeignKey } from './generators/foreign-keys.js';
+import { generateCreateFunction, generateDropFunction, } from './generators/functions.js';
 import { generateCreateIndex, generateDropIndex, } from './generators/indexes.js';
 import { generateColumnDefinition, generateTable } from './generators/tables.js';
 import { generateCreateTrigger, generateDropTrigger, } from './generators/triggers.js';
-import { getDirectives, getDefaultExpression, getEnumNames, getModelNames, getStoredFields, normalizeIndexDirective, normalizeTriggerDirective, parseForeignKeySignature, } from './utils/ast-helpers.js';
+import { getDirectives, getDefaultExpression, getEnumNames, getModelNames, getStoredFields, normalizeFunction, normalizeIndexDirective, normalizeTriggerDirective, parseForeignKeySignature, } from './utils/ast-helpers.js';
 import { quoteIdentifier, toSnakeCase, toTableName } from './utils/snake-case.js';
 const MIGRATION_ORDER = {
     CreateExtension: 0,
@@ -18,10 +19,13 @@ const MIGRATION_ORDER = {
     DropConstraint: 8,
     DropIndex: 9,
     CreateIndex: 10,
-    CreateTrigger: 11,
-    DropTrigger: 12,
-    DropTable: 13,
-    DropExtension: 14,
+    DropFunction: 11,
+    CreateFunction: 12,
+    ReplaceFunction: 13,
+    CreateTrigger: 14,
+    DropTrigger: 15,
+    DropTable: 16,
+    DropExtension: 17,
 };
 export class MigrationSqlGenerator {
     generate(migrations, newSchema) {
@@ -32,12 +36,20 @@ export class MigrationSqlGenerator {
         const modelNames = getModelNames(newSchema);
         const modelMap = new Map(newSchema.models.map((model) => [model.name, model]));
         const enumMap = new Map(newSchema.enums.map((enumDef) => [enumDef.name, enumDef]));
+        const functionMap = new Map(newSchema.functions.map((sqlFunction) => [sqlFunction.name, sqlFunction]));
         const ordered = [...migrations].sort((left, right) => MIGRATION_ORDER[left.kind] - MIGRATION_ORDER[right.kind]);
-        const statements = ordered.map((migration) => this.migrationToSql(migration, { newSchema, enumNames, modelNames, modelMap, enumMap }));
+        const statements = ordered.map((migration) => this.migrationToSql(migration, {
+            newSchema,
+            enumNames,
+            modelNames,
+            modelMap,
+            enumMap,
+            functionMap,
+        }));
         return `${statements.join('\n\n')}\n`;
     }
     migrationToSql(migration, context) {
-        const { enumNames, modelNames, modelMap, enumMap } = context;
+        const { enumNames, modelNames, modelMap, enumMap, functionMap } = context;
         switch (migration.kind) {
             case 'CreateExtension':
                 return generateCreateExtension(migration.extensionName);
@@ -147,6 +159,18 @@ export class MigrationSqlGenerator {
                 const normalized = JSON.parse(migration.signature);
                 return generateDropTrigger(model, normalized);
             }
+            case 'CreateFunction':
+            case 'ReplaceFunction': {
+                const sqlFunction = functionMap.get(migration.functionName);
+                if (!sqlFunction) {
+                    throw new Error(`Function "${migration.functionName}" not found in new schema`);
+                }
+                return generateCreateFunction(normalizeFunction(sqlFunction, enumNames));
+            }
+            case 'DropFunction': {
+                const normalized = JSON.parse(migration.signature);
+                return generateDropFunction(normalized);
+            }
             default: {
                 const exhaustive = migration;
                 throw new Error(`Unsupported migration kind: ${exhaustive.kind}`);

package/dist/sql-generator/migration-types.d.ts

@@ -1,4 +1,4 @@
-export type Migration = CreateExtension | DropExtension | CreateTable | DropTable | AddColumn | DropColumn | AlterColumn | CreateIndex | DropIndex | CreateEnum | AddEnumValue | AddConstraint | DropConstraint | CreateTrigger | DropTrigger;
+export type Migration = CreateExtension | DropExtension | CreateTable | DropTable | AddColumn | DropColumn | AlterColumn | CreateIndex | DropIndex | CreateEnum | AddEnumValue | AddConstraint | DropConstraint | CreateFunction | ReplaceFunction | DropFunction | CreateTrigger | DropTrigger;
 export interface CreateTable {
     kind: 'CreateTable';
     modelName: string;
@@ -84,3 +84,16 @@ export interface DropTrigger {
     modelName: string;
     signature: string;
 }
+export interface CreateFunction {
+    kind: 'CreateFunction';
+    functionName: string;
+}
+export interface ReplaceFunction {
+    kind: 'ReplaceFunction';
+    functionName: string;
+}
+export interface DropFunction {
+    kind: 'DropFunction';
+    functionName: string;
+    signature: string;
+}

package/dist/sql-generator/sql-generator.js

@@ -3,6 +3,7 @@ import { generateDropTables } from './generators/drop-tables.js';
 import { generateEnums } from './generators/enums.js';
 import { generateExtensions } from './generators/extensions.js';
 import { generateForeignKeys } from './generators/foreign-keys.js';
+import { generateFunctions } from './generators/functions.js';
 import { generateIndexes } from './generators/indexes.js';
 import { generateTables } from './generators/tables.js';
 import { generateTriggers } from './generators/triggers.js';
@@ -15,6 +16,7 @@ export class SqlGenerator {
             generateTables(schema),
             generateForeignKeys(schema),
             generateIndexes(schema),
+            generateFunctions(schema),
             generateTriggers(schema),
         ];
         return `${sections.join('\n')}\n`;

package/dist/sql-generator/utils/ast-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { Attribute, AttributeArgs, Directive, Field, KeyValueArgs, Model, Schema, TypeExpr, Value } from '../../schema-dsl/ast.js';
+import type { Attribute, AttributeArgs, Directive, Field, KeyValueArgs, Model, Schema, SqlFunction, TypeExpr, Value } from '../../schema-dsl/ast.js';
 export interface PrimaryKeyInfo {
     fields: string[];
     composite: boolean;
@@ -56,3 +56,21 @@ export interface TriggerNames {
 }
 export declare function normalizeTriggerDirective(directive: Directive): NormalizedTrigger;
 export declare function resolveTriggerNames(model: Model, timing: string, event: string): TriggerNames;
+export interface NormalizedFunctionParam {
+    name: string;
+    sqlName: string;
+    sqlType: string;
+}
+export interface NormalizedFunction {
+    name: string;
+    sqlName: string;
+    params: NormalizedFunctionParam[];
+    returns: string;
+    language: string;
+    volatility: string;
+    security: string;
+    execute: string;
+}
+export declare function normalizeFunction(sqlFunction: SqlFunction, enumNames: Set<string>): NormalizedFunction;
+export declare function functionIdentity(normalized: NormalizedFunction): string;
+export declare function functionSignature(normalized: NormalizedFunction): string;

package/dist/sql-generator/utils/ast-helpers.js

@@ -250,3 +250,29 @@ export function resolveTriggerNames(model, timing, event) {
         triggerName: `${baseName}_trigger`,
     };
 }
+export function normalizeFunction(sqlFunction, enumNames) {
+    return {
+        name: sqlFunction.name,
+        sqlName: toSnakeCase(sqlFunction.name),
+        params: sqlFunction.params.map((param) => ({
+            name: param.name,
+            sqlName: toSnakeCase(param.name),
+            sqlType: serializeColumnType(param.type, enumNames),
+        })),
+        returns: serializeColumnType(sqlFunction.returns, enumNames),
+        language: (sqlFunction.language ?? 'sql').toLowerCase(),
+        volatility: (sqlFunction.volatility ?? 'VOLATILE').toUpperCase(),
+        security: (sqlFunction.security ?? 'INVOKER').toUpperCase(),
+        execute: sqlFunction.execute.trim(),
+    };
+}
+export function functionIdentity(normalized) {
+    return JSON.stringify({
+        sqlName: normalized.sqlName,
+        params: normalized.params.map((param) => param.sqlType),
+        returns: normalized.returns,
+    });
+}
+export function functionSignature(normalized) {
+    return JSON.stringify(normalized);
+}

package/dist/sql-generator/utils/type-mapper.js

@@ -13,6 +13,9 @@ const PRIMITIVE_TYPES = new Set([
     'TIMESTAMP',
 ]);
 export function mapColumnType(type, enumNames) {
+    if (type.name === 'TRIGGER' || type.name === 'VOID') {
+        return type.name;
+    }
     const baseType = mapBaseType(type, enumNames);
     return type.array ? `${baseType}[]` : baseType;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "schematic-pg",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Single-file backend framework for PostgreSQL and Node.js",
   "type": "module",
   "license": "MIT",