vouchington-tooling 0.0.9 → 0.0.11

package/dist/openapi-document/contract-schema-intersection-merge.mjs

@@ -0,0 +1,96 @@
+import { hashContractSchema } from './contract-schema-canonical.mjs';
+/**
+ * Structurally merges an all-object intersection instead of emitting raw `allOf`: the
+ * extractor defaults `additionalProperties:false`, so `allOf` of two closed objects is
+ * unsatisfiable. Falls back to raw `allOf` only when a member isn't an object (directly or
+ * via `ref`), where that unsatisfiability concern doesn't apply. `nodeToOpenApi` is passed in
+ * (rather than imported) so this module doesn't form an import cycle with the dispatcher.
+ */
+export function intersectionToOpenApi(node, ctx, nodeToOpenApi) {
+    const resolved = node.variants.map((variant) => resolveObjectVariant(variant, ctx.definitions));
+    if (resolved.some((variant) => variant === undefined)) {
+        return { allOf: node.variants.map((variant) => nodeToOpenApi(variant, ctx)) };
+    }
+    const properties = {};
+    for (const variant of resolved) {
+        for (const [key, property] of Object.entries(variant.properties)) {
+            const existing = properties[key];
+            if (existing &&
+                hashSchemaNode(existing.schema, ctx) !== hashSchemaNode(property.schema, ctx)) {
+                // A member re-declaring a shared key with a strictly narrower type is a common, valid
+                // TypeScript intersection idiom (e.g. `Omit`-free overriding of an optional/nullable
+                // field to a guaranteed-present one) — TypeScript itself resolves the property to the
+                // narrower type, not a conflict. Prefer whichever side is the narrower one; only two
+                // genuinely incompatible schemas (neither a subset of the other) are a real conflict.
+                if (isNarrowerVariant(property.schema, existing.schema, ctx)) {
+                    properties[key] = {
+                        schema: property.schema,
+                        required: existing.required || property.required,
+                    };
+                    continue;
+                }
+                /* v8 ignore next 6 -- symmetric of the previous branch; covered by order-swapped fixtures */
+                if (isNarrowerVariant(existing.schema, property.schema, ctx)) {
+                    properties[key] = {
+                        schema: existing.schema,
+                        required: existing.required || property.required,
+                    };
+                    continue;
+                }
+                throw new Error(`Cannot merge intersection: property "${key}" has conflicting schemas across members`);
+            }
+            properties[key] = {
+                schema: property.schema,
+                required: existing?.required || property.required,
+            };
+        }
+    }
+    const sortedKeys = Object.keys(properties).toSorted();
+    const required = sortedKeys.filter((key) => properties[key].required);
+    return {
+        type: 'object',
+        properties: Object.fromEntries(sortedKeys.map((key) => [key, nodeToOpenApi(properties[key].schema, ctx)])),
+        ...(required.length > 0 ? { required } : {}),
+        additionalProperties: false,
+    };
+}
+// Bounds intersection-merge ref resolution so a cyclic or pathologically deep `definitions`
+// chain can't hang the converter; falls back to raw `allOf` if the object is still unresolved
+// past this many hops (comfortably above the extractor's actual definition-nesting depths).
+const MAX_REF_RESOLUTION_HOPS = 5;
+function resolveObjectVariant(node, definitions) {
+    const resolved = resolveRef(node, definitions);
+    return resolved.type === 'object' ? resolved : undefined;
+}
+/** Follows a `ref` chain (bounded by `MAX_REF_RESOLUTION_HOPS`) to its underlying node, whatever shape that turns out to be. Returns the node unchanged if it isn't a `ref`, or if the chain doesn't resolve within the hop budget. */
+function resolveRef(node, definitions) {
+    let current = node;
+    for (let hop = 0; hop < MAX_REF_RESOLUTION_HOPS && current.type === 'ref'; hop++) {
+        const next = definitions[current.name];
+        if (!next)
+            return current;
+        current = next;
+    }
+    return current;
+}
+function hashSchemaNode(node, ctx) {
+    return hashContractSchema({ root: node, definitions: ctx.definitions });
+}
+/**
+ * True when every value `narrow` accepts is also accepted by `wide` — i.e. `narrow`'s own variant
+ * set (a non-union schema is its own single-variant set) is a subset of `wide`'s. Covers the
+ * realistic case this converter needs to handle (an intersection member narrowing a shared
+ * optional/nullable property to a guaranteed-present one, e.g. `string | null` narrowed to
+ * `string`) without attempting full structural subtyping for arbitrary object shapes.
+ *
+ * Both sides are `ref`-resolved first: a shared property declared with its own named union alias
+ * (e.g. `post_type: PostType`) extracts as a `ref` to that alias, not an inline `union` node, so
+ * checking `.type === 'union'` on the raw node would miss it entirely.
+ */
+function isNarrowerVariant(narrow, wide, ctx) {
+    const resolvedNarrow = resolveRef(narrow, ctx.definitions);
+    const resolvedWide = resolveRef(wide, ctx.definitions);
+    const narrowVariants = resolvedNarrow.type === 'union' ? resolvedNarrow.variants : [resolvedNarrow];
+    const wideHashes = new Set((resolvedWide.type === 'union' ? resolvedWide.variants : [resolvedWide]).map((variant) => hashSchemaNode(variant, ctx)));
+    return narrowVariants.every((variant) => wideHashes.has(hashSchemaNode(variant, ctx)));
+}

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

@@ -0,0 +1,7 @@
+import type { ContractSchemaNode } from './contract-schema-types.mts';
+import type { OpenApiSchema } from './openapi-types.mts';
+export type OpenApiConverterContext = {
+    definitions: Record<string, ContractSchemaNode>;
+    refName: (name: string) => string;
+};
+export declare function nodeToOpenApi(node: ContractSchemaNode, ctx: OpenApiConverterContext): OpenApiSchema;

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)),
+    };
+}