vouchington-tooling 0.0.10 → 0.0.11

package/dist/openapi-document/contract-schema-to-openapi.mjs

@@ -0,0 +1,71 @@
+import { intersectionToOpenApi } from './contract-schema-intersection-merge.mjs';
+export function nodeToOpenApi(node, ctx) {
+    switch (node.type) {
+        case 'unknown':
+            return {};
+        case 'null':
+            return { type: 'null' };
+        case 'boolean':
+        case 'number':
+        case 'string':
+            return { type: node.type };
+        case 'literal':
+            return { const: node.value };
+        case 'array':
+            return { type: 'array', items: nodeToOpenApi(node.items, ctx) };
+        case 'tuple':
+            return tupleToOpenApi(node, ctx);
+        case 'object':
+            return objectToOpenApi(node, ctx);
+        case 'union':
+            return unionToOpenApi(node, ctx);
+        case 'intersection':
+            return intersectionToOpenApi(node, ctx, nodeToOpenApi);
+        case 'ref':
+            return { $ref: `#/components/schemas/${ctx.refName(node.name)}` };
+    }
+}
+function tupleToOpenApi(node, ctx) {
+    const prefixItems = node.items.map((item) => nodeToOpenApi(item, ctx));
+    const minItems = node.items.length - node.optionalItems;
+    if (node.rest) {
+        return { type: 'array', prefixItems, minItems, items: nodeToOpenApi(node.rest, ctx) };
+    }
+    return { type: 'array', prefixItems, minItems, items: false, maxItems: node.items.length };
+}
+function objectToOpenApi(node, ctx) {
+    const keys = Object.keys(node.properties).toSorted();
+    const properties = {};
+    const required = [];
+    for (const key of keys) {
+        const property = node.properties[key];
+        properties[key] = nodeToOpenApi(property.schema, ctx);
+        if (property.required)
+            required.push(key);
+    }
+    return {
+        type: 'object',
+        properties,
+        ...(required.length > 0 ? { required } : {}),
+        additionalProperties: node.additionalProperties === false ? false : nodeToOpenApi(node.additionalProperties, ctx),
+    };
+}
+const LITERAL_TYPES = { boolean: 'boolean', number: 'number', string: 'string' };
+function unionToOpenApi(node, ctx) {
+    return (literalUnionEnum(node) ?? { anyOf: node.variants.map((variant) => nodeToOpenApi(variant, ctx)) });
+}
+function literalUnionEnum(node) {
+    if (node.variants.length === 0)
+        return undefined;
+    if (!node.variants.every((variant) => variant.type === 'literal'))
+        return undefined;
+    const literals = node.variants;
+    const type = LITERAL_TYPES[typeof literals[0].value];
+    const sameType = literals.every((literal) => LITERAL_TYPES[typeof literal.value] === type);
+    if (!sameType)
+        return undefined;
+    const values = [...new Set(literals.map((literal) => literal.value))].toSorted((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    if (type === 'boolean' && values.length === 2)
+        return { type: 'boolean' };
+    return { type, enum: values };
+}

package/dist/openapi-document/contract-schema-types.d.mts

@@ -0,0 +1,43 @@
+export type ContractSchema = {
+    root: ContractSchemaNode;
+    definitions: Record<string, ContractSchemaNode>;
+};
+export type ContractSchemaNode = {
+    type: 'unknown';
+} | {
+    type: 'null';
+} | {
+    type: 'boolean';
+} | {
+    type: 'number';
+} | {
+    type: 'string';
+} | {
+    type: 'literal';
+    value: boolean | number | string;
+} | {
+    type: 'array';
+    items: ContractSchemaNode;
+} | {
+    type: 'tuple';
+    items: ContractSchemaNode[];
+    optionalItems: number;
+    rest?: ContractSchemaNode;
+} | {
+    type: 'object';
+    properties: Record<string, ContractSchemaProperty>;
+    additionalProperties: false | ContractSchemaNode;
+} | {
+    type: 'union';
+    variants: ContractSchemaNode[];
+} | {
+    type: 'intersection';
+    variants: ContractSchemaNode[];
+} | {
+    type: 'ref';
+    name: string;
+};
+export type ContractSchemaProperty = {
+    required: boolean;
+    schema: ContractSchemaNode;
+};

package/dist/openapi-document/contract-schema-types.mjs

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

package/dist/openapi-document/index.d.mts

@@ -0,0 +1,19 @@
+export { buildOpenApiDocument } from './build-openapi-document.mts';
+export type { BuildOpenApiDocumentInput } from './build-openapi-document.mts';
+export { queryParameters } from './build-openapi-query.mts';
+export { buildOperationRequestBody } from './build-openapi-request.mts';
+export { buildOperationResponse } from './build-openapi-response.mts';
+export { createComponentRegistry, sanitizeComponentName } from './component-registry.mts';
+export type { ComponentRegistry } from './component-registry.mts';
+export { canonicalContractSchema, hashContractSchema } from './contract-schema-canonical.mts';
+export { nodeToOpenApi } from './contract-schema-to-openapi.mts';
+export type { OpenApiConverterContext } from './contract-schema-to-openapi.mts';
+export type { ContractSchema, ContractSchemaNode, ContractSchemaProperty, } from './contract-schema-types.mts';
+export { responseStatusCodesForContract, routeShape, type QueryOperationContract, type RegisteredRoute, type RequestContract, type ResponseContract, } from './operation-types.mts';
+export { registerOpenApiErrorResponse } from './openapi-error-response.mts';
+export { canonicalTemplatesByShape, catalogResponse, operationId, pathParameters, } from './openapi-route-helpers.mts';
+export type { OpenApiDocument, OpenApiOperation, OpenApiParameter, OpenApiRequestBody, OpenApiResponse, OpenApiSchema, } from './openapi-types.mts';
+export type { OpenApiQueryContract, OpenApiQueryParameter } from './query-types.mts';
+export { objectNode, requiredProperty } from './schema-node-builders.mts';
+export { writeOpenApi } from './write-openapi.mts';
+export type { WriteOpenApiOptions } from './write-openapi.mts';

package/dist/openapi-document/index.mjs

@@ -0,0 +1,12 @@
+export { buildOpenApiDocument } from './build-openapi-document.mjs';
+export { queryParameters } from './build-openapi-query.mjs';
+export { buildOperationRequestBody } from './build-openapi-request.mjs';
+export { buildOperationResponse } from './build-openapi-response.mjs';
+export { createComponentRegistry, sanitizeComponentName } from './component-registry.mjs';
+export { canonicalContractSchema, hashContractSchema } from './contract-schema-canonical.mjs';
+export { nodeToOpenApi } from './contract-schema-to-openapi.mjs';
+export { responseStatusCodesForContract, routeShape, } from './operation-types.mjs';
+export { registerOpenApiErrorResponse } from './openapi-error-response.mjs';
+export { canonicalTemplatesByShape, catalogResponse, operationId, pathParameters, } from './openapi-route-helpers.mjs';
+export { objectNode, requiredProperty } from './schema-node-builders.mjs';
+export { writeOpenApi } from './write-openapi.mjs';

package/dist/openapi-document/openapi-error-response.d.mts

@@ -0,0 +1,2 @@
+import type { ComponentRegistry } from './component-registry.mts';
+export declare function registerOpenApiErrorResponse(registry: ComponentRegistry): void;

package/dist/openapi-document/openapi-error-response.mjs

@@ -0,0 +1,13 @@
+const ERROR_BODY_NODE = {
+    type: 'object',
+    properties: {
+        message: { required: true, schema: { type: 'string' } },
+        code: { required: false, schema: { type: 'string' } },
+        request_id: { required: false, schema: { type: 'string' } },
+        stack: { required: false, schema: { type: 'string' } },
+    },
+    additionalProperties: false,
+};
+export function registerOpenApiErrorResponse(registry) {
+    registry.register('openapi-error-response', { ErrorBody: ERROR_BODY_NODE });
+}

package/dist/openapi-document/openapi-route-helpers.d.mts

@@ -0,0 +1,9 @@
+import type { OpenApiParameter, OpenApiResponseOrRef } from './openapi-types.mts';
+export declare function canonicalTemplatesByShape(routeTemplates: readonly string[]): Map<string, string>;
+export declare function pathParameters(routeTemplate: string): OpenApiParameter[];
+export declare function operationId(method: string, routeTemplate: string): string;
+export declare function catalogResponse(kind: 'ordinary' | 'sse' | 'error-only' | 'fixed-no-content', fixedStatus?: number): {
+    responses: Record<number, OpenApiResponseOrRef>;
+    unavailable: boolean;
+    unavailableReason?: string;
+};

package/dist/openapi-document/openapi-route-helpers.mjs

@@ -0,0 +1,61 @@
+import { STATUS_CODES } from 'node:http';
+import { routeShape } from './operation-types.mjs';
+export function canonicalTemplatesByShape(routeTemplates) {
+    const canonical = new Map();
+    for (const routeTemplate of routeTemplates) {
+        const shape = routeShape(routeTemplate);
+        const existing = canonical.get(shape);
+        if (!existing || routeTemplate.localeCompare(existing) < 0)
+            canonical.set(shape, routeTemplate);
+    }
+    return canonical;
+}
+export function pathParameters(routeTemplate) {
+    return [...routeTemplate.matchAll(/:(\w+)/g)].map((match) => ({
+        name: match[1],
+        in: 'path',
+        required: true,
+        schema: { type: 'string' },
+    }));
+}
+export function operationId(method, routeTemplate) {
+    const path = routeTemplate.replace(/^\//, '').replace(/[/:]+/g, '_');
+    return `${method.toLowerCase()}_${path}`;
+}
+export function catalogResponse(kind, fixedStatus) {
+    if (kind === 'fixed-no-content') {
+        if (fixedStatus === undefined)
+            throw new Error('fixed-no-content route requires a status');
+        return {
+            responses: {
+                [fixedStatus]: { description: STATUS_CODES[fixedStatus] ?? 'Response' },
+            },
+            unavailable: false,
+        };
+    }
+    if (kind === 'error-only') {
+        const reason = 'registered route has no success response';
+        return {
+            responses: { 405: { $ref: '#/components/responses/Error' } },
+            unavailable: true,
+            unavailableReason: reason,
+        };
+    }
+    const reason = kind === 'sse'
+        ? 'SSE event payload sequence is not statically extracted'
+        : 'registered route has no statically recognized response emission';
+    return {
+        responses: kind === 'sse'
+            ? {
+                200: {
+                    description: 'OK',
+                    content: { 'text/event-stream': { schema: {} } },
+                    'x-schema-unavailable': true,
+                    'x-schema-unavailable-reason': reason,
+                },
+            }
+            : {},
+        unavailable: true,
+        unavailableReason: reason,
+    };
+}

package/dist/openapi-document/openapi-types.d.mts

@@ -0,0 +1,80 @@
+export type OpenApiSchema = {
+    $ref?: string;
+    type?: 'null' | 'boolean' | 'integer' | 'number' | 'string' | 'array' | 'object';
+    format?: 'uri' | 'uuid';
+    const?: boolean | number | string;
+    enum?: (boolean | number | string)[];
+    items?: OpenApiSchema | false;
+    prefixItems?: OpenApiSchema[];
+    minItems?: number;
+    maxItems?: number;
+    minimum?: number;
+    maximum?: number;
+    pattern?: string;
+    default?: boolean | number | string;
+    properties?: Record<string, OpenApiSchema>;
+    required?: string[];
+    additionalProperties?: false | OpenApiSchema;
+    anyOf?: OpenApiSchema[];
+    allOf?: OpenApiSchema[];
+};
+export type OpenApiParameter = {
+    name: string;
+    in: 'path';
+    required: true;
+    schema: {
+        type: 'string';
+    };
+} | {
+    name: string;
+    in: 'query';
+    required: false;
+    description?: string;
+    style?: 'form';
+    explode?: false;
+    schema: OpenApiSchema;
+};
+export type OpenApiResponse = {
+    description: string;
+    content?: Record<string, {
+        schema: OpenApiSchema;
+    }>;
+    'x-schema-unavailable'?: true;
+    'x-schema-unavailable-reason'?: string;
+};
+export type OpenApiResponseOrRef = OpenApiResponse | {
+    $ref: string;
+};
+export type OpenApiRequestBody = {
+    content: {
+        'application/json': {
+            schema: OpenApiSchema;
+        };
+    };
+    'x-request-schema-unavailable'?: true;
+    'x-request-schema-unavailable-reason'?: string;
+};
+export type OpenApiOperation = {
+    operationId: string;
+    parameters?: OpenApiParameter[];
+    requestBody?: OpenApiRequestBody;
+    responses: Record<string, OpenApiResponseOrRef>;
+    'x-schema-unavailable'?: true;
+    'x-schema-unavailable-reason'?: string;
+};
+export type OpenApiDocument = {
+    openapi: '3.1.0';
+    info: {
+        title: string;
+        version: string;
+    };
+    paths: Record<string, Record<string, OpenApiOperation>>;
+    components: {
+        schemas: Record<string, OpenApiSchema>;
+        responses: {
+            Error: OpenApiResponse;
+        };
+    };
+    'x-unavailable-routes': string[];
+    'x-unavailable-request-routes': string[];
+};

package/dist/openapi-document/openapi-types.mjs

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

package/dist/openapi-document/operation-types.d.mts

@@ -0,0 +1,35 @@
+import type { ContractSchema } from './contract-schema-types.mts';
+import type { OpenApiQueryContract } from './query-types.mts';
+export type ResponseContract = {
+    source: string;
+    schema: ContractSchema;
+    method: string;
+    routeTemplate: string;
+    statusCodes?: readonly [number, ...number[]];
+    statusKnowledge?: 'default' | 'explicit' | 'unknown';
+    bodyKind?: 'content' | 'none';
+    mediaType?: string;
+    mediaTypeKnowledge?: 'known' | 'none' | 'unknown';
+    unavailableReason?: string;
+};
+export type RequestContract = {
+    source: string;
+    schema: ContractSchema;
+    method: string;
+    routeTemplate: string;
+    unavailableReason?: string;
+};
+export type QueryOperationContract = {
+    method: string;
+    routeTemplate: string;
+    parameters: OpenApiQueryContract;
+};
+export type RegisteredRoute = {
+    method: string;
+    routeTemplate: string;
+    kind: 'ordinary' | 'sse' | 'error-only' | 'fixed-no-content';
+    fixedStatus?: number;
+    source: string;
+};
+export declare function responseStatusCodesForContract(contract: ResponseContract): number[];
+export declare function routeShape(routeTemplate: string): string;

package/dist/openapi-document/operation-types.mjs

@@ -0,0 +1,11 @@
+export function responseStatusCodesForContract(contract) {
+    if (contract.statusKnowledge === 'unknown')
+        return [];
+    if (contract.statusCodes)
+        return [...new Set(contract.statusCodes)].toSorted((a, b) => a - b);
+    const bodyKind = contract.bodyKind ?? (contract.schema.root.type === 'null' ? 'none' : 'content');
+    return [bodyKind === 'none' ? 204 : 200];
+}
+export function routeShape(routeTemplate) {
+    return routeTemplate.replace(/:[^/]+/g, ':');
+}

package/dist/openapi-document/query-types.d.mts

@@ -0,0 +1,35 @@
+export type OpenApiQueryParameter = {
+    kind: 'string';
+    format?: 'uuid' | 'uri';
+    description?: string;
+} | {
+    kind: 'uuid-or-uri';
+    description?: string;
+} | {
+    kind: 'boolean';
+    description?: string;
+} | {
+    kind: 'nullable-boolean';
+    description?: string;
+} | {
+    kind: 'number';
+    description?: string;
+} | {
+    kind: 'integer';
+    minimum: number;
+    maximum: number;
+    default?: number;
+    description?: string;
+} | {
+    kind: 'enum';
+    values: readonly string[];
+    default?: string;
+    description?: string;
+} | {
+    kind: 'csv-array';
+    items: OpenApiQueryParameter;
+    style: 'form';
+    explode: false;
+    description?: string;
+};
+export type OpenApiQueryContract = Readonly<Record<string, OpenApiQueryParameter>>;

package/dist/openapi-document/query-types.mjs

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

package/dist/openapi-document/schema-node-builders.d.mts

@@ -0,0 +1,3 @@
+import type { ContractSchemaNode, ContractSchemaProperty } from './contract-schema-types.mts';
+export declare function objectNode(properties?: Record<string, ContractSchemaProperty>): ContractSchemaNode;
+export declare function requiredProperty(schema: ContractSchemaNode, required?: boolean): ContractSchemaProperty;

package/dist/openapi-document/schema-node-builders.mjs

@@ -0,0 +1,6 @@
+export function objectNode(properties = {}) {
+    return { type: 'object', properties, additionalProperties: false };
+}
+export function requiredProperty(schema, required = true) {
+    return { required, schema };
+}

package/dist/openapi-document/write-openapi.d.mts

@@ -0,0 +1,9 @@
+import type { OpenApiDocument } from './openapi-types.mts';
+export type WriteOpenApiOptions = {
+    path: string;
+    document: OpenApiDocument;
+    check?: boolean;
+    format?: (path: string, raw: string) => Promise<string>;
+    stringify?: (value: unknown) => string;
+};
+export declare function writeOpenApi(options: WriteOpenApiOptions): Promise<void>;

package/dist/openapi-document/write-openapi.mjs

@@ -0,0 +1,19 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+function defaultStringify(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export async function writeOpenApi(options) {
+    const stringify = options.stringify ?? defaultStringify;
+    const format = options.format ?? (async (_path, raw) => raw);
+    const content = await format(options.path, stringify(options.document));
+    if (options.check) {
+        const actual = await readFile(options.path, 'utf8').catch((error) => error.code === 'ENOENT' ? null : Promise.reject(error));
+        if (actual !== content) {
+            throw new Error(`${options.path} is stale. Regenerate the OpenAPI document and commit it.`);
+        }
+        return;
+    }
+    await mkdir(dirname(options.path), { recursive: true });
+    await writeFile(options.path, content);
+}

package/dist/pg-schema-snapshot/build-snapshot.d.mts

@@ -0,0 +1,9 @@
+import type { SchemaCatalog } from './catalog-queries.mts';
+import type { SchemaGrowthMaps, SchemaSnapshot } from './types.mts';
+export { buildTableSnapshots } from './table-snapshot.mts';
+/**
+ * Transforms raw pg_catalog rows into the committed, name-keyed schema snapshot object. Pure —
+ * no I/O. Table-specific catalog validation and structured facts live in table-snapshot.mts;
+ * this module owns the remaining schema-wide object groups and final deterministic assembly.
+ */
+export declare function buildSchemaSnapshot(catalog: SchemaCatalog, growth: SchemaGrowthMaps): SchemaSnapshot;

package/dist/pg-schema-snapshot/build-snapshot.mjs

@@ -0,0 +1,61 @@
+import { groupBy, keyed } from './snapshot-build-utils.mjs';
+import { buildTableSnapshots } from './table-snapshot.mjs';
+export { buildTableSnapshots } from './table-snapshot.mjs';
+/**
+ * Transforms raw pg_catalog rows into the committed, name-keyed schema snapshot object. Pure —
+ * no I/O. Table-specific catalog validation and structured facts live in table-snapshot.mts;
+ * this module owns the remaining schema-wide object groups and final deterministic assembly.
+ */
+export function buildSchemaSnapshot(catalog, growth) {
+    const tables = buildTableSnapshots({
+        catalog,
+        columnsByTable: groupBy(catalog.columns, (row) => row.table_name),
+        constraintsByTable: groupBy(catalog.constraints, (row) => row.table_name),
+        indexesByTable: groupBy(catalog.indexes, (row) => row.table_name),
+        triggersByTable: groupBy(catalog.triggers, (row) => row.table_name),
+        growth,
+    });
+    const enumValuesByName = groupBy(catalog.enums, (row) => row.enum_name);
+    const views = {};
+    for (const view of catalog.views) {
+        views[view.view_name] = {
+            definition: view.definition,
+            comment: view.comment,
+            materialized: view.materialized,
+        };
+    }
+    const enums = {};
+    for (const [enumName, values] of enumValuesByName) {
+        enums[enumName] = { values: values.map((value) => value.value) };
+    }
+    const extensions = {};
+    for (const extension of catalog.extensions) {
+        extensions[extension.extension_name] = { version: extension.version };
+    }
+    const functions = {};
+    for (const fn of catalog.functions) {
+        const key = fn.identity_arguments
+            ? `${fn.function_name}(${fn.identity_arguments})`
+            : fn.function_name;
+        functions[key] = { definition: fn.definition };
+    }
+    const policies = {};
+    for (const policy of catalog.policies) {
+        policies[`${policy.table_name}.${policy.policy_name}`] = {
+            table: policy.table_name,
+            command: policy.command,
+            pgRoles: policy.pg_roles,
+            using: policy.using_expression,
+            withCheck: policy.with_check_expression,
+        };
+    }
+    return {
+        formatVersion: 2,
+        tables,
+        views: keyed(Object.entries(views)),
+        enums: keyed(Object.entries(enums)),
+        extensions: keyed(Object.entries(extensions)),
+        functions: keyed(Object.entries(functions)),
+        policies: keyed(Object.entries(policies)),
+    };
+}

package/dist/pg-schema-snapshot/catalog-objects.d.mts

@@ -0,0 +1,34 @@
+import type { CatalogQuery } from './types.mts';
+export type CatalogEnumValueRow = {
+    enum_name: string;
+    value: string;
+    sort_order: number;
+};
+export declare function readEnums(query: CatalogQuery): Promise<CatalogEnumValueRow[]>;
+export type CatalogViewRow = {
+    view_name: string;
+    materialized: boolean;
+    definition: string;
+    comment: string | null;
+};
+export declare function readViews(query: CatalogQuery): Promise<CatalogViewRow[]>;
+export type CatalogExtensionRow = {
+    extension_name: string;
+    version: string;
+};
+export declare function readExtensions(query: CatalogQuery): Promise<CatalogExtensionRow[]>;
+export type CatalogFunctionRow = {
+    function_name: string;
+    identity_arguments: string;
+    definition: string;
+};
+export declare function readFunctions(query: CatalogQuery): Promise<CatalogFunctionRow[]>;
+export type CatalogPolicyRow = {
+    table_name: string;
+    policy_name: string;
+    command: string;
+    pg_roles: string[];
+    using_expression: string | null;
+    with_check_expression: string | null;
+};
+export declare function readPolicies(query: CatalogQuery): Promise<CatalogPolicyRow[]>;

package/dist/pg-schema-snapshot/catalog-objects.mjs

@@ -0,0 +1,64 @@
+import { EXCLUDE_EXTENSION_OWNED } from './catalog-shared.mjs';
+export async function readEnums(query) {
+    const { rows } = await query(`/* readSchemaSnapshotEnums */
+      SELECT
+        target.typname AS enum_name,
+        pg_enum.enumlabel AS value,
+        pg_enum.enumsortorder AS sort_order
+      FROM pg_enum
+      JOIN pg_type target ON target.oid = pg_enum.enumtypid
+      JOIN pg_namespace ON pg_namespace.oid = target.typnamespace
+      WHERE pg_namespace.nspname = 'public'
+        AND ${EXCLUDE_EXTENSION_OWNED}
+      ORDER BY enum_name, sort_order`);
+    return rows;
+}
+export async function readViews(query) {
+    const { rows } = await query(`/* readSchemaSnapshotViews */
+      SELECT
+        target.relname AS view_name,
+        target.relkind = 'm' AS materialized,
+        pg_get_viewdef(target.oid) AS definition,
+        obj_description(target.oid, 'pg_class') AS comment
+      FROM pg_class target
+      JOIN pg_namespace ON pg_namespace.oid = target.relnamespace
+      WHERE pg_namespace.nspname = 'public'
+        AND target.relkind = ANY($1)
+        AND ${EXCLUDE_EXTENSION_OWNED}
+      ORDER BY view_name`, [['v', 'm']]);
+    return rows;
+}
+export async function readExtensions(query) {
+    const { rows } = await query(`/* readSchemaSnapshotExtensions */
+      SELECT extname AS extension_name, extversion AS version
+      FROM pg_extension
+      ORDER BY extension_name`);
+    return rows;
+}
+export async function readFunctions(query) {
+    const { rows } = await query(`/* readSchemaSnapshotFunctions */
+      SELECT
+        target.proname AS function_name,
+        pg_get_function_identity_arguments(target.oid) AS identity_arguments,
+        pg_get_functiondef(target.oid) AS definition
+      FROM pg_proc target
+      JOIN pg_namespace ON pg_namespace.oid = target.pronamespace
+      WHERE pg_namespace.nspname = 'public'
+        AND ${EXCLUDE_EXTENSION_OWNED}
+      ORDER BY function_name, identity_arguments`);
+    return rows;
+}
+export async function readPolicies(query) {
+    const { rows } = await query(`/* readSchemaSnapshotPolicies */
+      SELECT
+        tablename AS table_name,
+        policyname AS policy_name,
+        cmd AS command,
+        roles AS pg_roles,
+        qual AS using_expression,
+        with_check AS with_check_expression
+      FROM pg_policies
+      WHERE schemaname = 'public'
+      ORDER BY table_name, policy_name`);
+    return rows;
+}

package/dist/pg-schema-snapshot/catalog-queries.d.mts

@@ -0,0 +1,20 @@
+import { type CatalogEnumValueRow, type CatalogExtensionRow, type CatalogFunctionRow, type CatalogPolicyRow, type CatalogViewRow, readEnums, readExtensions, readFunctions, readPolicies, readViews } from './catalog-objects.mts';
+import { type CatalogConstraintRow, readConstraints } from './catalog-table-constraints.mts';
+import { type CatalogIndexRow, type CatalogTriggerRow, readIndexes, readTriggers } from './catalog-table-indexes.mts';
+import { type CatalogColumnRow, type CatalogTableRow, readColumns, readTables } from './catalog-tables.mts';
+import type { CatalogQuery } from './types.mts';
+export { readColumns, readConstraints, readEnums, readExtensions, readFunctions, readIndexes, readPolicies, readTables, readTriggers, readViews, };
+export type { CatalogColumnRow, CatalogConstraintRow, CatalogEnumValueRow, CatalogExtensionRow, CatalogFunctionRow, CatalogIndexRow, CatalogPolicyRow, CatalogTableRow, CatalogTriggerRow, CatalogViewRow, };
+export type SchemaCatalog = {
+    tables: CatalogTableRow[];
+    columns: CatalogColumnRow[];
+    constraints: CatalogConstraintRow[];
+    indexes: CatalogIndexRow[];
+    triggers: CatalogTriggerRow[];
+    enums: CatalogEnumValueRow[];
+    views: CatalogViewRow[];
+    extensions: CatalogExtensionRow[];
+    functions: CatalogFunctionRow[];
+    policies: CatalogPolicyRow[];
+};
+export declare function readSchemaCatalog(query: CatalogQuery): Promise<SchemaCatalog>;