@tricoteuses/senat 3.0.1 → 3.0.2

package/lib/src/scripts/retrieve_open_data.js

@@ -3,7 +3,6 @@ import { execFileSync } from "child_process";
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
 import { formatWithPrettier, makePgTsGenerator, markAsGenerated, processDatabase } from "kanel";
-import { makeGenerateZodSchemas } from "kanel-zod";
 import path from "path";
 import StreamZip from "node-stream-zip";
 import readline from "readline";
@@ -16,6 +15,7 @@ import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js"
 import { buildIncrementalDatasetImportSql, buildNormalizeStagingSchemaSql } from "./shared/incremental_import_sql.js";
 import { buildGeneratedTableManifest, getGeneratedDefinitionPath, getGeneratedTableManifestPath, prefixedName, rawTypesDir, senatSchemaName, stagingSchemaName, stripDatasetPrefix, } from "./shared/prefixed_tables.js";
 import { buildEnsureSchemaVersionTableSql, buildIncrementSchemaVersionSql, buildSchemaStructureFingerprintQuery, } from "./shared/schema_version.js";
+import { makeGenerateZodSchemas } from "./shared/make_generate_zod_schemas.js";
 import { buildExportStagingMetadataStatementsQuery } from "./shared/staging_metadata_sql.js";
 import { isCopyFromStdinLine, rewriteLineForStagingImport } from "./shared/staging_import.js";
 const badWindows1252CharacterRegex = /[\u0080-\u009f]/g;

package/lib/src/scripts/shared/make_generate_zod_schemas.d.ts

@@ -0,0 +1,20 @@
+import type { TableColumn, TableDetails } from "extract-pg-schema";
+import { type Details, type Path, type PgTsGeneratorContext, type PgTsPreRenderHook, type TypeMap } from "kanel";
+type GenerateFor = "selector" | "initializer" | "mutator" | undefined;
+type ZodSchemaMetadata = {
+    comment?: string[];
+    name: string;
+    path: Path;
+};
+type ZodIdentifierMetadata = {
+    comment?: string[];
+    name: string;
+};
+type GenerateZodSchemasConfig = {
+    castToSchema?: boolean;
+    getZodIdentifierMetadata?: (column: TableColumn, details: TableDetails, context: PgTsGeneratorContext) => ZodIdentifierMetadata;
+    getZodSchemaMetadata?: (details: Details, generateFor: GenerateFor, context: PgTsGeneratorContext) => ZodSchemaMetadata;
+    zodTypeMap?: TypeMap;
+};
+export declare function makeGenerateZodSchemas(config?: GenerateZodSchemasConfig): PgTsPreRenderHook;
+export {};

package/lib/src/scripts/shared/make_generate_zod_schemas.js

@@ -0,0 +1,300 @@
+import { escapeName, resolveType, useKanelContext, } from "kanel";
+import { defaultGetZodIdentifierMetadata, defaultGetZodSchemaMetadata, defaultZodTypeMap } from "kanel-zod";
+const zImport = {
+    asName: undefined,
+    importAsType: false,
+    isAbsolute: true,
+    isDefault: false,
+    name: "z",
+    path: "zod",
+};
+function appendTsDeclaration(output, path, declaration) {
+    const file = output[path];
+    if (!file || file.fileType !== "typescript") {
+        throw new Error(`Path ${path} is not a typescript file`);
+    }
+    file.declarations.push(declaration);
+}
+function toMetaQualifier(comment) {
+    if (!comment || comment.length === 0) {
+        return undefined;
+    }
+    const description = comment.join(" ").replace(/\n/g, " ");
+    return `meta({ description: ${JSON.stringify(description)} })`;
+}
+function generateProperties(details, generateFor, nonCompositeTypeImports, compositeTypeImports, identifierTypeImports, zodTypeMap, context) {
+    const properties = details.kind === "compositeType" ? [...details.attributes] : [...details.columns];
+    const sortedProperties = context.propertySortFunction ? properties.sort(context.propertySortFunction) : properties;
+    return sortedProperties.map((property) => {
+        const { comment, name, nullableOverride, optionalOverride, typeOverride } = context.getPropertyMetadata(property, details, generateFor);
+        const canBeOptional = property.isNullable || property.defaultValue || property.isIdentity;
+        const resolvedType = typeOverride ?? resolveType(property, details);
+        let zodType = "z.unknown()";
+        const typeImports = [];
+        if (typeof resolvedType !== "string" && `${details.schemaName}.${resolvedType.name}` in identifierTypeImports) {
+            const typeImport = identifierTypeImports[`${details.schemaName}.${resolvedType.name}`];
+            typeImports.push(typeImport);
+            zodType = typeImport.name;
+        }
+        else if (property.type.fullName in zodTypeMap) {
+            const mappedType = zodTypeMap[property.type.fullName];
+            if (typeof mappedType === "string") {
+                zodType = mappedType;
+                if ("dimensions" in property) {
+                    for (let i = property.dimensions || 0; i > 0; i -= 1) {
+                        zodType = `${zodType}.array()`;
+                    }
+                }
+            }
+            else {
+                zodType = mappedType.name;
+                typeImports.push(...mappedType.typeImports);
+            }
+        }
+        else if (property.type.fullName in nonCompositeTypeImports) {
+            const typeImport = nonCompositeTypeImports[property.type.fullName];
+            typeImports.push(typeImport);
+            zodType = typeImport.name;
+        }
+        else if (property.type.fullName in compositeTypeImports) {
+            const typeImport = compositeTypeImports[property.type.fullName];
+            typeImports.push(typeImport);
+            zodType = typeImport.name;
+            if (property.isArray) {
+                zodType = `${zodType}.array()`;
+            }
+            if (property.isNullable) {
+                zodType = `${zodType}.nullable()`;
+            }
+        }
+        else {
+            console.error(`kanel-zod: Unknown type for ${name}.${property.name}: ${property.type.fullName}`);
+        }
+        let isOptional;
+        if (optionalOverride === undefined) {
+            switch (generateFor) {
+                case "selector":
+                    isOptional = false;
+                    break;
+                case "initializer":
+                    isOptional = Boolean(canBeOptional);
+                    break;
+                case "mutator":
+                    isOptional = true;
+                    break;
+            }
+        }
+        else {
+            isOptional = optionalOverride;
+        }
+        const qualifiers = [];
+        if (isOptional) {
+            qualifiers.push("optional()");
+        }
+        if (nullableOverride ?? property.isNullable) {
+            qualifiers.push("nullable()");
+        }
+        const metaQualifier = toMetaQualifier(comment);
+        if (metaQualifier) {
+            qualifiers.push(metaQualifier);
+        }
+        return {
+            name,
+            typeImports,
+            value: qualifiers.length > 0 ? `${zodType}.${qualifiers.join(".")}` : zodType,
+        };
+    });
+}
+function buildCompositeDeclaration(details, generateFor, nonCompositeTypeImports, compositeTypeImports, identifierTypeImports, getZodSchemaMetadata, zodTypeMap, castToSchema, context) {
+    const { comment, name } = getZodSchemaMetadata(details, generateFor, context);
+    const { name: typescriptTypeName } = context.getMetadata(details, generateFor);
+    const properties = generateProperties(details, generateFor, nonCompositeTypeImports, compositeTypeImports, identifierTypeImports, zodTypeMap, context);
+    const typeImports = [zImport];
+    const value = ["z.object({", ...properties.map((property) => `  ${escapeName(property.name)}: ${property.value},`)];
+    if (castToSchema) {
+        value.push(`}) as unknown as z.Schema<${typescriptTypeName}>`);
+    }
+    else {
+        value.push("})");
+    }
+    properties.forEach((property) => {
+        typeImports.push(...property.typeImports);
+    });
+    return {
+        comment,
+        declarationType: "constant",
+        exportAs: "named",
+        name,
+        type: undefined,
+        typeImports,
+        value,
+    };
+}
+function buildIdentifierDeclarations(details, getZodIdentifierMetadata, zodTypeMap, castToSchema, nonCompositeTypeImports, context) {
+    if (!context.generateIdentifierType) {
+        return [];
+    }
+    const generateIdentifierType = context.generateIdentifierType;
+    return details.columns
+        .filter((column) => column.isPrimaryKey && !column.reference)
+        .map((column) => {
+        const typescriptDeclaration = generateIdentifierType(column, details);
+        const { comment, name } = getZodIdentifierMetadata(column, details, context);
+        let zodType = "z.unknown()";
+        const typeImports = [zImport];
+        if (column.type.fullName in zodTypeMap) {
+            const mappedType = zodTypeMap[column.type.fullName];
+            if (typeof mappedType === "string") {
+                zodType = mappedType;
+            }
+            else {
+                zodType = mappedType.name;
+                typeImports.push(...mappedType.typeImports);
+            }
+        }
+        else if (column.type.fullName in nonCompositeTypeImports) {
+            const typeImport = nonCompositeTypeImports[column.type.fullName];
+            zodType = typeImport.name;
+            typeImports.push(typeImport);
+        }
+        return {
+            declaration: {
+                comment,
+                declarationType: "constant",
+                exportAs: "named",
+                name,
+                type: undefined,
+                typeImports,
+                value: castToSchema
+                    ? `${zodType} as unknown as z.Schema<${typescriptDeclaration.name}>`
+                    : `${zodType}.transform(value => value as ${typescriptDeclaration.name})`,
+            },
+            name,
+            originalName: typescriptDeclaration.name,
+        };
+    });
+}
+export function makeGenerateZodSchemas(config = {}) {
+    return async (outputAcc, context) => {
+        const kanelContext = useKanelContext();
+        const output = { ...outputAcc };
+        const getZodSchemaMetadata = config.getZodSchemaMetadata ?? defaultGetZodSchemaMetadata;
+        const getZodIdentifierMetadata = config.getZodIdentifierMetadata ?? defaultGetZodIdentifierMetadata;
+        const zodTypeMap = { ...defaultZodTypeMap, ...(config.zodTypeMap ?? {}) };
+        const castToSchema = config.castToSchema ?? true;
+        const nonCompositeTypeImports = {};
+        const identifierTypeImports = {};
+        const compositeTypeImports = {};
+        for (const schema of Object.values(kanelContext.schemas)) {
+            schema.enums?.forEach((enumDetails) => {
+                const { name, path } = getZodSchemaMetadata(enumDetails, undefined, context);
+                appendTsDeclaration(output, path, {
+                    comment: [`Zod schema for ${enumDetails.name}`],
+                    declarationType: "constant",
+                    exportAs: "named",
+                    name,
+                    type: undefined,
+                    typeImports: [zImport],
+                    value: ["z.enum([", ...enumDetails.values.map((value) => `  '${value}',`), "])"],
+                });
+                nonCompositeTypeImports[`${enumDetails.schemaName}.${enumDetails.name}`] = {
+                    asName: undefined,
+                    importAsType: false,
+                    isAbsolute: false,
+                    isDefault: false,
+                    name,
+                    path,
+                };
+            });
+            schema.ranges?.forEach((rangeDetails) => {
+                const { name, path } = getZodSchemaMetadata(rangeDetails, undefined, context);
+                appendTsDeclaration(output, path, {
+                    comment: [`Zod schema for ${rangeDetails.name}`],
+                    declarationType: "constant",
+                    exportAs: "named",
+                    name,
+                    type: undefined,
+                    typeImports: [zImport],
+                    value: "z.string()",
+                });
+                nonCompositeTypeImports[`${rangeDetails.schemaName}.${rangeDetails.name}`] = {
+                    asName: undefined,
+                    importAsType: false,
+                    isAbsolute: false,
+                    isDefault: false,
+                    name,
+                    path,
+                };
+            });
+            schema.domains?.forEach((domainDetails) => {
+                const { name, path } = getZodSchemaMetadata(domainDetails, undefined, context);
+                const domainType = zodTypeMap[domainDetails.innerType] ?? "z.unknown()";
+                appendTsDeclaration(output, path, {
+                    comment: [`Zod schema for ${domainDetails.name}`],
+                    declarationType: "constant",
+                    exportAs: "named",
+                    name,
+                    type: undefined,
+                    typeImports: [zImport, ...(typeof domainType === "string" ? [] : domainType.typeImports)],
+                    value: typeof domainType === "string" ? domainType : domainType.name,
+                });
+                nonCompositeTypeImports[`${domainDetails.schemaName}.${domainDetails.name}`] = {
+                    asName: undefined,
+                    importAsType: false,
+                    isAbsolute: false,
+                    isDefault: false,
+                    name,
+                    path,
+                };
+            });
+            schema.tables?.forEach((tableDetails) => {
+                const { path } = getZodSchemaMetadata(tableDetails, undefined, context);
+                const declarations = buildIdentifierDeclarations(tableDetails, getZodIdentifierMetadata, zodTypeMap, castToSchema, nonCompositeTypeImports, context);
+                declarations.forEach(({ declaration, name, originalName }) => {
+                    appendTsDeclaration(output, path, declaration);
+                    identifierTypeImports[`${tableDetails.schemaName}.${originalName}`] = {
+                        asName: undefined,
+                        importAsType: false,
+                        isAbsolute: false,
+                        isDefault: false,
+                        name,
+                        path,
+                    };
+                });
+            });
+            [
+                ...(schema.tables ?? []),
+                ...(schema.views ?? []),
+                ...(schema.materializedViews ?? []),
+                ...(schema.compositeTypes ?? []),
+            ].forEach((compositeDetails) => {
+                const { name, path } = getZodSchemaMetadata(compositeDetails, undefined, context);
+                compositeTypeImports[`${compositeDetails.schemaName}.${compositeDetails.name}`] = {
+                    asName: undefined,
+                    importAsType: false,
+                    isAbsolute: false,
+                    isDefault: false,
+                    name,
+                    path,
+                };
+            });
+        }
+        for (const schema of Object.values(kanelContext.schemas)) {
+            ;
+            [
+                ...(schema.tables ?? []),
+                ...(schema.views ?? []),
+                ...(schema.materializedViews ?? []),
+                ...(schema.compositeTypes ?? []),
+            ].forEach((compositeDetails) => {
+                const { path } = getZodSchemaMetadata(compositeDetails, undefined, context);
+                appendTsDeclaration(output, path, buildCompositeDeclaration(compositeDetails, "selector", nonCompositeTypeImports, compositeTypeImports, identifierTypeImports, getZodSchemaMetadata, zodTypeMap, castToSchema, context));
+                if (compositeDetails.kind === "table") {
+                    appendTsDeclaration(output, path, buildCompositeDeclaration(compositeDetails, "initializer", nonCompositeTypeImports, compositeTypeImports, identifierTypeImports, getZodSchemaMetadata, zodTypeMap, castToSchema, context));
+                    appendTsDeclaration(output, path, buildCompositeDeclaration(compositeDetails, "mutator", nonCompositeTypeImports, compositeTypeImports, identifierTypeImports, getZodSchemaMetadata, zodTypeMap, castToSchema, context));
+                }
+            });
+        }
+        return output;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tricoteuses/senat",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Handle French Sénat's open data",
   "keywords": [
     "France",
@@ -46,7 +46,6 @@
     "access": "public"
   },
   "scripts": {
-    "postinstall": "patch-package",
     "build": "tsc",
     "build:types": "tsc --emitDeclarationOnly",
     "data:convert_data": "tsx src/scripts/convert_data.ts",
@@ -101,8 +100,6 @@
     "globals": "^17.0.0",
     "kanel": "^4.0.1",
     "kanel-zod": "^4.0.0",
-    "patch-package": "^8.0.1",
-    "postinstall-postinstall": "^2.1.0",
     "prettier": "^3.5.3",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",