npm - schematic-pg - Versions diffs - 0.1.11 → 0.1.13 - Mend

schematic-pg 0.1.11 → 0.1.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md +2 -2
package/dist/api/openapi.d.ts +7 -0
package/dist/api/openapi.js +27 -0
package/dist/api-generator/app-generator.js +4 -0
package/dist/api-generator/index.d.ts +2 -0
package/dist/api-generator/index.js +9 -4
package/dist/api-generator/openapi-generator.d.ts +29 -0
package/dist/api-generator/openapi-generator.js +509 -0
package/dist/cli/generate.js +2 -0
package/dist/cli/templates/agents.md +1 -1
package/dist/cli/templates.d.ts +1 -1
package/dist/cli/templates.js +1 -1
package/dist/cli.js +1 -1
package/dist/db/bootstrap.js +3 -0
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -449,14 +449,14 @@ npm run start      # schematic-pg start
 ```bash
 schematic-pg db:ping [schema]              # Test DATABASE_URL connection (SELECT 1)
-schematic-pg db:bootstrap [schema]         # Apply DDL from schema + write .schema-state snapshot
+schematic-pg db:bootstrap [schema]         # Reset public schema, apply DDL, write .schema-state snapshot
 schematic-pg db:diff [schema]              # Print pending schema changes (snapshot vs app.schema)
 schematic-pg db:diff --name add_users      # Write a migration file under migrations/
 schematic-pg db:migrate [schema]           # Apply pending migration files
 schematic-pg db:migrate:status [schema]    # Show snapshot + migration file status
 ```
-`db:bootstrap` is the recommended first-time setup. Use `db:diff` / `db:migrate` when evolving an existing database.
+`db:bootstrap` resets the `public` schema then applies full DDL — safe to re-run locally (including via `dev` watch). Use `db:diff` / `db:migrate` when evolving a database you need to keep.
 For a full walkthrough (mental model, local loop, and automating staging/production with GitHub Actions), see [Migrations tutorial](docs/migrations.md).

package/dist/api/openapi.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Hono } from 'hono';
+/**
+ * Mounts public API docs routes:
+ * - GET /openapi.json — OpenAPI document
+ * - GET /docs — Scalar API reference UI (CDN)
+ */
+export declare function mountApiDocs(app: Hono, document: object): void;

package/dist/api/openapi.js ADDED Viewed

@@ -0,0 +1,27 @@
+const SCALAR_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>API Reference</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+    <script>
+      Scalar.createApiReference('#app', {
+        url: '/openapi.json',
+      });
+    </script>
+  </body>
+</html>
+`;
+/**
+ * Mounts public API docs routes:
+ * - GET /openapi.json — OpenAPI document
+ * - GET /docs — Scalar API reference UI (CDN)
+ */
+export function mountApiDocs(app, document) {
+    app.get('/openapi.json', (c) => c.json(document));
+    app.get('/docs', (c) => c.html(SCALAR_HTML));
+}

package/dist/api-generator/app-generator.js CHANGED Viewed

@@ -40,6 +40,7 @@ export class AppGenerator {
             "import { createDbClient } from './db.js';",
             "import { POLICIES } from './policies.js';",
             "import { HOOKS } from './hooks.js';",
+            "import { openApiDocument } from './openapi.js';",
             `import { configurePolicies } from '${PACKAGE_NAME}/api/auth/policy';`,
             `import { configureHooks } from '${PACKAGE_NAME}/api/hooks';`,
             `import { createAuthMiddleware } from '${PACKAGE_NAME}/api/auth/middleware';`,
@@ -47,6 +48,7 @@ export class AppGenerator {
             `import type { AuthResolver } from '${PACKAGE_NAME}/api/auth/types';`,
             `import { createDbMiddleware } from '${PACKAGE_NAME}/api/middleware/db';`,
             `import { handleError } from '${PACKAGE_NAME}/api/middleware/errors';`,
+            `import { mountApiDocs } from '${PACKAGE_NAME}/api/openapi';`,
             `import type { AppEnv } from '${PACKAGE_NAME}/api/types';`,
             '',
             'configurePolicies(POLICIES);',
@@ -59,6 +61,7 @@ export class AppGenerator {
             '',
             'export function createApp(options: CreateAppOptions = {}): Hono<AppEnv> {',
             '  const app = new Hono<AppEnv>();',
+            '  mountApiDocs(app, openApiDocument);',
             '  app.use(logger());',
             '  app.use(prettyJSON());',
             '  app.use(createDbMiddleware({ pool: options.pool, createDbClient }));',
@@ -76,6 +79,7 @@ export class AppGenerator {
             '  const port = Number(process.env.PORT ?? 3000);',
             '  serve({ fetch: createApp().fetch, port }, () => {',
             '    console.log(`Server running at http://localhost:${port}`);',
+            '    console.log(`API docs at http://localhost:${port}/docs`);',
             '  });',
             '}',
             '',

package/dist/api-generator/index.d.ts CHANGED Viewed

@@ -5,6 +5,8 @@ export interface GeneratedApiFiles {
     validation: string;
     hooks: string;
     routes: Map<string, string>;
+    openapiTs: string;
+    openapiJson: string;
 }
 export interface GenerateApiFilesOptions {
     customRoutesDir?: string;

package/dist/api-generator/index.js CHANGED Viewed

@@ -1,21 +1,26 @@
-import { DEFAULT_HOOKS_DIR } from '../cli/paths.js';
+import { DEFAULT_CUSTOM_ROUTES_DIR, DEFAULT_HOOKS_DIR } from '../cli/paths.js';
 import { generateAppFile } from './app-generator.js';
+import { discoverCustomRoutes } from './custom-route-scanner.js';
 import { discoverHooks } from './hook-scanner.js';
 import { generateHooksFile } from './hooks-generator.js';
+import { generateOpenApiFiles } from './openapi-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;
+    const customRoutesDir = options?.customRoutesDir ?? DEFAULT_CUSTOM_ROUTES_DIR;
+    const appOptions = { customRoutesDir };
     const hooksDir = options?.hooksDir ?? DEFAULT_HOOKS_DIR;
     const { entries: hookEntries, modelsWithHooks } = discoverHooks(hooksDir, schema);
+    const includeAuthPaths = discoverCustomRoutes(customRoutesDir).some((entry) => entry.basePath === 'auth');
+    const openapi = generateOpenApiFiles(schema, { includeAuthPaths });
     return {
         app: generateAppFile(schema, appOptions),
         policies: generatePoliciesFile(schema),
         validation: generateValidationSchemas(schema),
         hooks: generateHooksFile(hookEntries),
         routes: generateRouteFiles(schema, modelsWithHooks),
+        openapiTs: openapi.openapiTs,
+        openapiJson: openapi.openapiJson,
     };
 }

package/dist/api-generator/openapi-generator.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+import type { Schema } from '../schema-dsl/ast.js';
+export interface OpenApiGeneratorOptions {
+    includeAuthPaths?: boolean;
+}
+type OpenApiDocument = Record<string, unknown>;
+export declare class OpenApiGenerator {
+    private readonly schema;
+    private readonly options;
+    constructor(schema: Schema, options?: OpenApiGeneratorOptions);
+    generate(): OpenApiDocument;
+    generateJson(): string;
+    generateTsModule(): string;
+    private buildModelComponentSchemas;
+    private buildModelPaths;
+    private buildListQueryParameters;
+    private buildIncludeParameter;
+    private buildPathParameters;
+    private filterParamSchema;
+    private fieldToOpenApiSchema;
+    private mapTypeToOpenApi;
+    private buildAuthComponentSchemas;
+    private buildAuthPaths;
+}
+export declare function generateOpenApiDocument(schema: Schema, options?: OpenApiGeneratorOptions): OpenApiDocument;
+export declare function generateOpenApiFiles(schema: Schema, options?: OpenApiGeneratorOptions): {
+    openapiTs: string;
+    openapiJson: string;
+};
+export {};

package/dist/api-generator/openapi-generator.js ADDED Viewed

@@ -0,0 +1,509 @@
+import { toRouteBasePath } from '../api/utils/route-naming.js';
+import { fieldHasAttribute, getModelNames, getPrimaryKey, getStoredFields, } from '../sql-generator/utils/ast-helpers.js';
+import { getFilterableFields, getIncludableRelationFields, getOmittedFields, getSortableFieldNames, isStoredScalarField, } from './utils/api-fields.js';
+import { buildFilterFieldMeta, queryParamKey } from './utils/filter-operators.js';
+const ERROR_REF = { $ref: '#/components/schemas/Error' };
+const ERROR_EXAMPLE_VALIDATION = 'Validation failed';
+const ERROR_EXAMPLE_FORBIDDEN = 'Role "USER" is not allowed to list this resource';
+const ERROR_EXAMPLE_CONFLICT = 'Unique constraint violation on email';
+const OPTIONAL_BEARER_SECURITY = [{}, { bearerAuth: [] }];
+function errorResponse(description, exampleMessage = description) {
+    return {
+        description,
+        content: {
+            'application/json': {
+                schema: ERROR_REF,
+                example: { error: exampleMessage },
+            },
+        },
+    };
+}
+function jsonContent(schema) {
+    return {
+        'application/json': {
+            schema,
+        },
+    };
+}
+export class OpenApiGenerator {
+    schema;
+    options;
+    constructor(schema, options = {}) {
+        this.schema = schema;
+        this.options = options;
+    }
+    generate() {
+        const schemas = {
+            Error: {
+                type: 'object',
+                required: ['error'],
+                properties: {
+                    error: {
+                        type: 'string',
+                        description: 'Human-readable error message',
+                    },
+                },
+            },
+        };
+        const paths = {};
+        for (const model of this.schema.models) {
+            Object.assign(schemas, this.buildModelComponentSchemas(model));
+            Object.assign(paths, this.buildModelPaths(model));
+        }
+        if (this.options.includeAuthPaths) {
+            Object.assign(schemas, this.buildAuthComponentSchemas());
+            Object.assign(paths, this.buildAuthPaths());
+        }
+        return {
+            openapi: '3.1.0',
+            info: {
+                title: 'schematic-pg API',
+                version: '1.0.0',
+                description: 'Auto-generated OpenAPI document from the schema AST. Regenerated by schematic-pg generate:api.',
+            },
+            components: {
+                securitySchemes: {
+                    bearerAuth: {
+                        type: 'http',
+                        scheme: 'bearer',
+                        bearerFormat: 'JWT',
+                    },
+                },
+                schemas,
+            },
+            paths,
+        };
+    }
+    generateJson() {
+        return `${JSON.stringify(this.generate(), null, 2)}\n`;
+    }
+    generateTsModule() {
+        const document = this.generate();
+        return [
+            '// Auto-generated by OpenApiGenerator. Do not edit manually.',
+            `export const openApiDocument = ${JSON.stringify(document, null, 2)} as const;`,
+            '',
+        ].join('\n');
+    }
+    buildModelComponentSchemas(model) {
+        const modelNames = getModelNames(this.schema);
+        const storedFields = getStoredFields(model, modelNames).filter((field) => isStoredScalarField(field, this.schema));
+        const primaryKey = getPrimaryKey(model);
+        const pkFields = new Set(primaryKey?.fields ?? []);
+        const omitted = new Set(getOmittedFields(model, this.schema).map((field) => field.name));
+        const responseProps = {};
+        const responseRequired = [];
+        for (const field of storedFields) {
+            if (omitted.has(field.name)) {
+                continue;
+            }
+            responseProps[field.name] = this.fieldToOpenApiSchema(field, {
+                nullable: Boolean(field.type.optional),
+            });
+            if (!field.type.optional) {
+                responseRequired.push(field.name);
+            }
+        }
+        const createProps = {};
+        const createRequired = [];
+        for (const field of storedFields) {
+            if (pkFields.has(field.name)) {
+                continue;
+            }
+            createProps[field.name] = this.fieldToOpenApiSchema(field, {
+                nullable: Boolean(field.type.optional),
+            });
+            const optional = Boolean(field.type.optional) || fieldHasAttribute(field, 'default');
+            if (!optional) {
+                createRequired.push(field.name);
+            }
+        }
+        const updateProps = {};
+        for (const field of storedFields) {
+            if (pkFields.has(field.name)) {
+                continue;
+            }
+            updateProps[field.name] = this.fieldToOpenApiSchema(field, {
+                nullable: Boolean(field.type.optional),
+            });
+        }
+        return {
+            [`${model.name}Response`]: {
+                type: 'object',
+                properties: responseProps,
+                ...(responseRequired.length > 0 ? { required: responseRequired } : {}),
+            },
+            [`${model.name}Create`]: {
+                type: 'object',
+                properties: createProps,
+                ...(createRequired.length > 0 ? { required: createRequired } : {}),
+            },
+            [`${model.name}Update`]: {
+                type: 'object',
+                properties: updateProps,
+            },
+        };
+    }
+    buildModelPaths(model) {
+        const basePath = toRouteBasePath(model.name);
+        const collectionPath = `/${basePath}`;
+        const primaryKey = getPrimaryKey(model);
+        const pkFields = primaryKey?.fields ?? [];
+        const itemPathSegments = pkFields.map((field) => `{${field}}`);
+        const itemPath = itemPathSegments.length > 0
+            ? `${collectionPath}/${itemPathSegments.join('/')}`
+            : collectionPath;
+        const responseRef = { $ref: `#/components/schemas/${model.name}Response` };
+        const createRef = { $ref: `#/components/schemas/${model.name}Create` };
+        const updateRef = { $ref: `#/components/schemas/${model.name}Update` };
+        const tag = model.name;
+        const paths = {
+            [collectionPath]: {
+                get: {
+                    tags: [tag],
+                    summary: `List ${model.name}`,
+                    operationId: `list${model.name}`,
+                    security: OPTIONAL_BEARER_SECURITY,
+                    parameters: this.buildListQueryParameters(model),
+                    responses: {
+                        '200': {
+                            description: `List of ${model.name}`,
+                            content: jsonContent({ type: 'array', items: responseRef }),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '401': errorResponse('Unauthorized'),
+                        '403': errorResponse('Forbidden', ERROR_EXAMPLE_FORBIDDEN),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+                post: {
+                    tags: [tag],
+                    summary: `Create ${model.name}`,
+                    operationId: `create${model.name}`,
+                    security: OPTIONAL_BEARER_SECURITY,
+                    requestBody: {
+                        required: true,
+                        content: jsonContent(createRef),
+                    },
+                    responses: {
+                        '201': {
+                            description: `Created ${model.name}`,
+                            content: jsonContent(responseRef),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '401': errorResponse('Unauthorized'),
+                        '403': errorResponse('Forbidden', ERROR_EXAMPLE_FORBIDDEN),
+                        '409': errorResponse('Conflict', ERROR_EXAMPLE_CONFLICT),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+            },
+        };
+        if (pkFields.length > 0) {
+            const pathParams = this.buildPathParameters(pkFields, model);
+            paths[itemPath] = {
+                get: {
+                    tags: [tag],
+                    summary: `Get ${model.name}`,
+                    operationId: `get${model.name}`,
+                    security: OPTIONAL_BEARER_SECURITY,
+                    parameters: [...pathParams, this.buildIncludeParameter(model)],
+                    responses: {
+                        '200': {
+                            description: `${model.name} record`,
+                            content: jsonContent(responseRef),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '401': errorResponse('Unauthorized'),
+                        '403': errorResponse('Forbidden', ERROR_EXAMPLE_FORBIDDEN),
+                        '404': errorResponse('Not found'),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+                put: {
+                    tags: [tag],
+                    summary: `Update ${model.name}`,
+                    operationId: `update${model.name}`,
+                    security: OPTIONAL_BEARER_SECURITY,
+                    parameters: pathParams,
+                    requestBody: {
+                        required: true,
+                        content: jsonContent(updateRef),
+                    },
+                    responses: {
+                        '200': {
+                            description: `Updated ${model.name}`,
+                            content: jsonContent(responseRef),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '401': errorResponse('Unauthorized'),
+                        '403': errorResponse('Forbidden', ERROR_EXAMPLE_FORBIDDEN),
+                        '404': errorResponse('Not found'),
+                        '409': errorResponse('Conflict', ERROR_EXAMPLE_CONFLICT),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+                delete: {
+                    tags: [tag],
+                    summary: `Delete ${model.name}`,
+                    operationId: `delete${model.name}`,
+                    security: OPTIONAL_BEARER_SECURITY,
+                    parameters: pathParams,
+                    responses: {
+                        '200': {
+                            description: `Deleted ${model.name}`,
+                            content: jsonContent(responseRef),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '401': errorResponse('Unauthorized'),
+                        '403': errorResponse('Forbidden', ERROR_EXAMPLE_FORBIDDEN),
+                        '404': errorResponse('Not found'),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+            };
+        }
+        return paths;
+    }
+    buildListQueryParameters(model) {
+        const filterableFields = getFilterableFields(model, this.schema);
+        const sortableFields = getSortableFieldNames(model, this.schema);
+        const parameters = [];
+        for (const field of filterableFields) {
+            const meta = buildFilterFieldMeta(field, this.schema);
+            for (const operator of meta.operators) {
+                const name = queryParamKey(field.name, operator);
+                parameters.push({
+                    name,
+                    in: 'query',
+                    required: false,
+                    schema: this.filterParamSchema(field, operator),
+                    description: operator === 'equals'
+                        ? `Filter by ${field.name}`
+                        : `Filter ${field.name} with ${operator}`,
+                });
+            }
+        }
+        parameters.push({
+            name: 'limit',
+            in: 'query',
+            required: false,
+            schema: { type: 'integer', minimum: 1, maximum: 100 },
+            description: 'Max rows to return (max 100)',
+        }, {
+            name: 'offset',
+            in: 'query',
+            required: false,
+            schema: { type: 'integer', minimum: 0 },
+            description: 'Number of rows to skip',
+        }, {
+            name: 'sort',
+            in: 'query',
+            required: false,
+            schema: { type: 'string' },
+            description: `Sort field (prefix with - for desc). Allowed: ${sortableFields.join(', ') || '(none)'}`,
+        }, this.buildIncludeParameter(model));
+        return parameters;
+    }
+    buildIncludeParameter(model) {
+        const relationNames = getIncludableRelationFields(model, this.schema).map((field) => field.name);
+        return {
+            name: 'include',
+            in: 'query',
+            required: false,
+            schema: { type: 'string' },
+            description: relationNames.length > 0
+                ? `Comma-separated relation paths (dot nesting). Available: ${relationNames.join(', ')}`
+                : 'Comma-separated relation paths (dot nesting)',
+        };
+    }
+    buildPathParameters(pkFieldNames, model) {
+        const modelNames = getModelNames(this.schema);
+        const storedFields = getStoredFields(model, modelNames);
+        return pkFieldNames.map((name) => {
+            const field = storedFields.find((candidate) => candidate.name === name);
+            return {
+                name,
+                in: 'path',
+                required: true,
+                schema: field
+                    ? this.fieldToOpenApiSchema(field, { nullable: false })
+                    : { type: 'string' },
+            };
+        });
+    }
+    filterParamSchema(field, operator) {
+        if (operator === 'in') {
+            return {
+                type: 'string',
+                description: 'Comma-separated values',
+            };
+        }
+        return this.fieldToOpenApiSchema(field, { nullable: false });
+    }
+    fieldToOpenApiSchema(field, options = { nullable: false }) {
+        const base = this.mapTypeToOpenApi(field.type);
+        if (!options.nullable) {
+            return base;
+        }
+        const type = base.type;
+        if (typeof type === 'string') {
+            return { ...base, type: [type, 'null'] };
+        }
+        return { anyOf: [base, { type: 'null' }] };
+    }
+    mapTypeToOpenApi(type) {
+        const enumType = this.schema.enums.find((enumDef) => enumDef.name === type.name);
+        if (enumType) {
+            return {
+                type: 'string',
+                enum: enumType.values,
+            };
+        }
+        if (type.array && type.name === 'TEXT') {
+            return {
+                type: 'array',
+                items: { type: 'string' },
+            };
+        }
+        switch (type.name) {
+            case 'UUID':
+                return { type: 'string', format: 'uuid' };
+            case 'VARCHAR':
+            case 'TEXT':
+                return { type: 'string' };
+            case 'INTEGER':
+            case 'SERIAL':
+            case 'SMALLINT':
+                return { type: 'integer' };
+            case 'BOOLEAN':
+                return { type: 'boolean' };
+            case 'TIMESTAMP':
+                return { type: 'string', format: 'date-time' };
+            case 'DECIMAL':
+                // Matches Zod create/update mapping (z.string()).
+                return { type: 'string' };
+            case 'JSONB':
+                return { type: 'object', additionalProperties: true };
+            case 'POINT':
+                return {};
+            default:
+                return { type: 'string' };
+        }
+    }
+    buildAuthComponentSchemas() {
+        return {
+            AuthRegisterRequest: {
+                type: 'object',
+                required: ['email', 'password'],
+                properties: {
+                    email: { type: 'string', format: 'email' },
+                    password: { type: 'string', minLength: 1 },
+                    name: { type: 'string', minLength: 1 },
+                },
+            },
+            AuthLoginRequest: {
+                type: 'object',
+                required: ['email', 'password'],
+                properties: {
+                    email: { type: 'string', format: 'email' },
+                    password: { type: 'string', minLength: 1 },
+                },
+            },
+            AuthTokenResponse: {
+                type: 'object',
+                required: ['token', 'user'],
+                properties: {
+                    token: { type: 'string' },
+                    user: { type: 'object', additionalProperties: true },
+                },
+            },
+            AuthMeResponse: {
+                type: 'object',
+                properties: {
+                    role: { type: 'string' },
+                    user: {
+                        anyOf: [
+                            {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                },
+                                additionalProperties: true,
+                            },
+                            { type: 'null' },
+                        ],
+                    },
+                },
+            },
+        };
+    }
+    buildAuthPaths() {
+        return {
+            '/auth/register': {
+                post: {
+                    tags: ['Auth'],
+                    summary: 'Register',
+                    operationId: 'authRegister',
+                    requestBody: {
+                        required: true,
+                        content: jsonContent({ $ref: '#/components/schemas/AuthRegisterRequest' }),
+                    },
+                    responses: {
+                        '201': {
+                            description: 'Registered user with access token',
+                            content: jsonContent({ $ref: '#/components/schemas/AuthTokenResponse' }),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '409': errorResponse('Conflict', ERROR_EXAMPLE_CONFLICT),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+            },
+            '/auth/login': {
+                post: {
+                    tags: ['Auth'],
+                    summary: 'Login',
+                    operationId: 'authLogin',
+                    requestBody: {
+                        required: true,
+                        content: jsonContent({ $ref: '#/components/schemas/AuthLoginRequest' }),
+                    },
+                    responses: {
+                        '200': {
+                            description: 'Access token and user',
+                            content: jsonContent({ $ref: '#/components/schemas/AuthTokenResponse' }),
+                        },
+                        '400': errorResponse('Validation error', ERROR_EXAMPLE_VALIDATION),
+                        '401': errorResponse('Invalid email or password'),
+                        '500': errorResponse('Internal server error'),
+                    },
+                },
+            },
+            '/auth/me': {
+                get: {
+                    tags: ['Auth'],
+                    summary: 'Current auth context',
+                    operationId: 'authMe',
+                    security: OPTIONAL_BEARER_SECURITY,
+                    responses: {
+                        '200': {
+                            description: 'Current auth context (PUBLIC when unauthenticated)',
+                            content: jsonContent({ $ref: '#/components/schemas/AuthMeResponse' }),
+                        },
+                    },
+                },
+            },
+        };
+    }
+}
+export function generateOpenApiDocument(schema, options) {
+    return new OpenApiGenerator(schema, options).generate();
+}
+export function generateOpenApiFiles(schema, options) {
+    const generator = new OpenApiGenerator(schema, options);
+    return {
+        openapiTs: generator.generateTsModule(),
+        openapiJson: generator.generateJson(),
+    };
+}

package/dist/cli/generate.js CHANGED Viewed

@@ -36,6 +36,8 @@ export async function generateApi(schemaPath) {
     await writeFile(path.join(outputDir, 'policies.ts'), files.policies, 'utf8');
     await writeFile(path.join(outputDir, 'hooks.ts'), files.hooks, 'utf8');
     await writeFile(path.join(schemasDir, 'validation.ts'), files.validation, 'utf8');
+    await writeFile(path.join(outputDir, 'openapi.ts'), files.openapiTs, 'utf8');
+    await writeFile(path.join(outputDir, 'openapi.json'), files.openapiJson, 'utf8');
     for (const [fileName, content] of files.routes) {
         await writeFile(path.join(routesDir, fileName), content, 'utf8');
     }

package/dist/cli/templates/agents.md CHANGED Viewed

@@ -264,7 +264,7 @@ Flow: `validate → assertPolicy → beforeHooks → db op → afterHooks → re
 schematic-pg generate              # schema.sql + db client + API
 schematic-pg dev [--no-watch]      # generate + bootstrap + server + watch
 schematic-pg start [--no-migrate]  # production: migrate + run server
-schematic-pg db:bootstrap            # first-time DDL apply
+schematic-pg db:bootstrap            # reset public schema + apply DDL
 schematic-pg db:diff [--name label]  # print or write migration
 schematic-pg db:migrate              # apply pending migrations
 schematic-pg hooks:add [--model X]   # scaffold src/hooks/{Model}.ts

package/dist/cli/templates.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@ 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\n    name:         VARCHAR(150)?\n    role:         UserRole     @default(USER)\n    passwordHash: VARCHAR(255)? @omit @unfilterable\n    createdAt:    TIMESTAMP    @default(now())\n\n    @policy(role: USER, allow: [select, update], 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\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/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 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";
 export declare const MAKEFILE_TEMPLATE = ".PHONY: dev\n\ndev:\n\tdocker compose up -d --wait\n\tnpx schematic-pg dev\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 CHANGED Viewed

@@ -53,7 +53,7 @@ export const DOCKER_COMPOSE_TEMPLATE = `services:
       POSTGRES_PASSWORD: postgrest
       POSTGRES_DB: postgrest
     volumes:
-      - ./docker_data/postgres:/var/lib/postgresql/data
+      - ./docker_data/postgres:/var/lib/postgresql
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U postgrest -d postgrest"]
       interval: 5s

package/dist/cli.js CHANGED Viewed

@@ -18,7 +18,7 @@ Commands:
   dev [schema] [--no-watch]  Generate, bootstrap DB, start server, watch schema
   start [schema] [--no-migrate]  Run production server (migrate DB, no generate/watch)
   db:ping                    Test database connection
-  db:bootstrap [schema]      Apply DDL and snapshot schema state
+  db:bootstrap [schema]      Reset public schema, apply DDL, snapshot state
   db:diff [schema]           Show schema diff (--name <name> to write migration)
   db:migrate [schema]        Apply pending migrations
   db:migrate:status [schema] Show migration status

package/dist/db/bootstrap.js CHANGED Viewed

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { SqlGenerator } from '../sql-generator/sql-generator.js';
 import { DatabaseClient } from './client.js';
+import { resetPublicSchema } from './reset-database.js';
 import { writeSnapshot } from './schema-state.js';
 export function generateBootstrapSql(schemaPath) {
     const source = readFileSync(schemaPath, 'utf8');
@@ -10,6 +11,8 @@ export function generateBootstrapSql(schemaPath) {
 export async function bootstrapDatabase(schemaPath = join(process.cwd(), 'app.schema'), client = new DatabaseClient()) {
     const sql = generateBootstrapSql(schemaPath);
     await client.withClient(async (pgClient) => {
+        // Bootstrap is greenfield: wipe existing objects so re-runs (e.g. `dev` watch) are idempotent.
+        await resetPublicSchema(pgClient);
         await pgClient.query(sql);
     });
     writeSnapshot(schemaPath);

package/package.json CHANGED Viewed

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