@tricoteuses/senat 3.0.1 → 3.1.0

package/lib/src/scripts/retrieve_open_data.js

@@ -3,19 +3,20 @@ 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 { makeKyselyHook } from "kanel-kysely";
 import path from "path";
 import StreamZip from "node-stream-zip";
 import readline from "readline";
 import { pipeline, Readable } from "stream";
 import { promisify } from "util";
 import * as windows1252 from "windows-1252";
-import config from "../config.js";
-import { getChosenDatasets, getEnabledDatasets } from "../datasets.js";
+import config from "../server/config.js";
+import { getChosenDatasets, getEnabledDatasets } from "../server/datasets.js";
 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 { buildGeneratedTableManifest, getGeneratedDefinitionPath, getGeneratedTableManifestPath, prefixedName, kanelTypesDir, kyselyTypesDir, 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;
@@ -29,7 +30,7 @@ const optionsDefinitions = [
     },
     {
         alias: "c",
-        help: "create TypeScript interfaces and Zod schemas from database tables into src/raw_types",
+        help: "create TypeScript interfaces, Zod schemas, and Kysely types from database tables",
         name: "schema",
         type: Boolean,
     },
@@ -379,11 +380,11 @@ function trimComment(comment) {
     return trimmed ? trimmed : undefined;
 }
 async function generateRawTypes(dataset, runtime, prefixedTables) {
-    await fs.ensureDir(rawTypesDir);
+    await fs.ensureDir(kanelTypesDir);
     const definitionFilePath = getGeneratedDefinitionPath(dataset.database);
     const manifestFilePath = getGeneratedTableManifestPath(dataset.database);
     const datasetPrefix = `${dataset.database}_`;
-    const datasetOutputPath = path.join(rawTypesDir, dataset.database);
+    const datasetOutputPath = path.join(kanelTypesDir, dataset.database);
     const generateZodSchemas = makeGenerateZodSchemas({
         castToSchema: true,
         getZodIdentifierMetadata: (column, details) => ({
@@ -447,7 +448,7 @@ async function generateRawTypes(dataset, runtime, prefixedTables) {
                 preRenderHooks: [generateZodSchemas],
             }),
         ],
-        outputPath: rawTypesDir,
+        outputPath: kanelTypesDir,
         postRenderHooks: [markAsGenerated, formatWithPrettier],
         schemaNames: [senatSchemaName],
         typescriptConfig: {
@@ -459,6 +460,68 @@ async function generateRawTypes(dataset, runtime, prefixedTables) {
     await fs.writeFile(definitionFilePath, generatedDefinition.replace(/\r\n/g, "\n"));
     await fs.writeFile(manifestFilePath, buildGeneratedTableManifest(dataset.database, prefixedTables));
 }
+async function generateKyselyTypes(dataset, runtime) {
+    const datasetPrefix = `${dataset.database}_`;
+    const datasetOutputDir = path.join(kyselyTypesDir, dataset.database);
+    await fs.remove(datasetOutputDir);
+    await fs.ensureDir(datasetOutputDir);
+    await processDatabase({
+        connection: {
+            database: runtime.target.name,
+            host: runtime.target.host,
+            password: runtime.target.password,
+            port: runtime.target.port,
+            user: runtime.target.user,
+        },
+        filter: (pgType) => pgType.schemaName === senatSchemaName && pgType.name.startsWith(datasetPrefix),
+        generators: [
+            makePgTsGenerator({
+                filter: (pgType) => pgType.schemaName === senatSchemaName && pgType.name.startsWith(datasetPrefix),
+                generateIdentifierType: (column, details, builtinType) => {
+                    const tableName = stripDatasetPrefix(details.name, dataset.database);
+                    return {
+                        ...builtinType,
+                        comment: undefined,
+                        name: toIdentifierName(tableName, column.name),
+                        typeDefinition: builtinType.typeDefinition.map((typeDefinition) => typeDefinition.replace(/ & \{ __flavor\?: '[^']+' \}/g, "").replace(/ & \{ __brand: '[^']+' \}/g, "")),
+                    };
+                },
+                getMetadata: (details, generateFor, builtinMetadata) => {
+                    const baseName = toPascalCase(stripDatasetPrefix(details.name, dataset.database));
+                    const suffix = generateFor === "selector" || generateFor === undefined ? "" : toPascalCase(generateFor);
+                    const tableComment = trimComment(details.comment);
+                    return {
+                        ...builtinMetadata,
+                        comment: tableComment ? [tableComment] : undefined,
+                        exportAs: generateFor === "selector" ? "default" : "named",
+                        name: `${baseName}${suffix}`,
+                        path: path.join(datasetOutputDir, baseName),
+                    };
+                },
+                getPropertyMetadata: (property, _details, _generateFor, builtinMetadata) => {
+                    const comment = trimComment(property.comment);
+                    return {
+                        ...builtinMetadata,
+                        comment: comment ? [comment] : undefined,
+                    };
+                },
+                preRenderHooks: [
+                    makeKyselyHook({
+                        databaseFilename: "Database",
+                        includeSchemaNameInTableName: false,
+                    }),
+                ],
+            }),
+        ],
+        outputPath: datasetOutputDir,
+        postRenderHooks: [markAsGenerated, formatWithPrettier],
+        schemaNames: [senatSchemaName],
+        typescriptConfig: {
+            enumStyle: "literal-union",
+            tsModuleFormat: "esm",
+        },
+    });
+}
 async function downloadFile(url, dest) {
     const response = await fetch(url);
     if (!response.ok) {
@@ -602,13 +665,14 @@ async function retrieveDataset(dataDir, dataset, options, runtime) {
         }
     }
     if (options["schema"]) {
-        await fs.ensureDir(rawTypesDir);
+        await fs.ensureDir(kanelTypesDir);
         if (!options["silent"]) {
             console.log(`Creating TypeScript definitions from prefixed ${senatSchemaName} tables ` +
                 `for '${dataset.database}' in database '${runtime.target.name}'...`);
         }
         const prefixedTables = listPrefixedTables(dataset, dataDir, options, runtime);
         await generateRawTypes(dataset, runtime, prefixedTables);
+        await generateKyselyTypes(dataset, runtime);
     }
 }
 function buildRuntimeContext() {

package/lib/src/scripts/retrieve_senateurs_photos.js

@@ -6,8 +6,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 // import stream from "stream"
 // import util from "util"
-import * as git from "../git.js";
-import { findActif as findActifSenateurs } from "../model/sens.js";
+import * as git from "../server/git.js";
+import { findActif as findActifSenateurs } from "../server/sens.js";
 import { slugify } from "../strings.js";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js";
 const optionsDefinitions = [

package/lib/src/scripts/retrieve_videos.js

@@ -3,9 +3,9 @@ import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
 import fsp from "fs/promises";
 import path from "path";
-import * as git from "../git.js";
-import { AGENDA_FOLDER, iterLoadSenatAgendas } from "../loaders.js";
-import { getSessionsFromStart, UNDEFINED_SESSION } from "../types/sessions.js";
+import * as git from "../server/git.js";
+import { AGENDA_FOLDER, iterLoadSenatAgendas } from "../server/loaders.js";
+import { getSessionsFromStart, UNDEFINED_SESSION } from "../other_types/sessions.js";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js";
 import { getAgendaSegmentTimecodes, buildSenatVodMasterM3u8FromNvs } from "../utils/nvs-parsing.js";
 import { epochToParisDateTime, isAmbiguousTimeOriginal, toTargetEpoch } from "../utils/date.js";

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

@@ -10,7 +10,8 @@ function buildConfiguredMergeKeysValues(datasetName, mergeKeys) {
         .sort(([leftTable], [rightTable]) => leftTable.localeCompare(rightTable))
         .map(([tableName, columns]) => {
         const sqlColumns = columns.map((columnName) => `'${escapeSqlLiteral(columnName)}'`).join(", ");
-        return `SELECT '${escapeSqlLiteral(prefixedName(datasetName, tableName))}' AS tablename, ARRAY[${sqlColumns}]::text[] AS key_columns`;
+        return (`SELECT '${escapeSqlLiteral(prefixedName(datasetName, tableName))}'` +
+            ` AS tablename, ARRAY[${sqlColumns}]::text[] AS key_columns`);
     })
         .join("\nUNION ALL\n");
 }
@@ -371,7 +372,10 @@ BEGIN
       IF column_row.generated_kind = 's' THEN
         column_definition :=
           column_definition ||
-          ' GENERATED ALWAYS AS (' || replace(column_row.default_expression, '${stagingSchema}.', '${senatSchemaName}.') || ') STORED';
+          ' GENERATED ALWAYS AS (' ||
+          replace(column_row.default_expression,
+            '${stagingSchema}.', '${senatSchemaName}.') ||
+          ') STORED';
       ELSIF column_row.identity_kind = 'a' THEN
         column_definition := column_definition || ' GENERATED ALWAYS AS IDENTITY';
       ELSIF column_row.identity_kind = 'd' THEN
@@ -599,8 +603,12 @@ BEGIN
       AND columns.table_name = table_row.tablename;
 
     SELECT
-      string_agg(format('%1$I = s.%1$I', columns.column_name), ', ' ORDER BY columns.ordinal_position),
-      string_agg(format('t.%1$I IS DISTINCT FROM s.%1$I', columns.column_name), ' OR ' ORDER BY columns.ordinal_position)
+      string_agg(
+        format('%1$I = s.%1$I', columns.column_name),
+        ', ' ORDER BY columns.ordinal_position),
+      string_agg(
+        format('t.%1$I IS DISTINCT FROM s.%1$I', columns.column_name),
+        ' OR ' ORDER BY columns.ordinal_position)
     INTO update_assignments, change_condition
     FROM information_schema.columns columns
     WHERE columns.table_schema = '${escapedStagingSchema}'
@@ -636,8 +644,12 @@ BEGIN
     END IF;
 
     SELECT
-      'jsonb_build_array(' || string_agg(format('t.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position) || ')',
-      'jsonb_build_array(' || string_agg(format('s.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position) || ')'
+      'jsonb_build_array(' ||
+        string_agg(format('t.%I', columns.column_name),
+          ', ' ORDER BY columns.ordinal_position) || ')',
+      'jsonb_build_array(' ||
+        string_agg(format('s.%I', columns.column_name),
+          ', ' ORDER BY columns.ordinal_position) || ')'
     INTO target_row_signature_expression, staging_row_signature_expression
     FROM information_schema.columns columns
     WHERE columns.table_schema = '${escapedStagingSchema}'
@@ -745,7 +757,10 @@ BEGIN
       END IF;
 
       EXECUTE format(
-        'INSERT INTO ${senatSchemaName}.%1$I (%2$s) SELECT %3$s FROM %4$I.%1$I s WHERE NOT EXISTS (SELECT 1 FROM ${senatSchemaName}.%1$I t WHERE %5$s)',
+        'INSERT INTO ${senatSchemaName}.%1$I (%2$s) ' ||
+        'SELECT %3$s FROM %4$I.%1$I s ' ||
+        'WHERE NOT EXISTS ' ||
+        '(SELECT 1 FROM ${senatSchemaName}.%1$I t WHERE %5$s)',
         table_row.tablename,
         column_list,
         staging_column_list,

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/lib/src/scripts/shared/prefixed_tables.d.ts

@@ -1,5 +1,6 @@
 export declare const senatSchemaName = "senat";
-export declare const rawTypesDir: string;
+export declare const kanelTypesDir: string;
+export declare const kyselyTypesDir: string;
 export declare function prefixedName(datasetName: string, relationName: string): string;
 export declare function stagingSchemaName(datasetName: string): string;
 export declare function escapeRegExp(text: string): string;

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

@@ -1,6 +1,7 @@
 import path from "path";
 export const senatSchemaName = "senat";
-export const rawTypesDir = path.resolve("src", "raw_types");
+export const kanelTypesDir = path.resolve("src", "kanel_types");
+export const kyselyTypesDir = path.resolve("src", "kysely_types");
 export function prefixedName(datasetName, relationName) {
     return `${datasetName}_${relationName}`;
 }
@@ -15,10 +16,10 @@ export function stripDatasetPrefix(relationName, datasetName) {
     return relationName.startsWith(datasetPrefix) ? relationName.slice(datasetPrefix.length) : relationName;
 }
 export function getGeneratedDefinitionPath(datasetName) {
-    return path.join(rawTypesDir, `${datasetName}.ts`);
+    return path.join(kanelTypesDir, `${datasetName}.ts`);
 }
 export function getGeneratedTableManifestPath(datasetName) {
-    return path.join(rawTypesDir, `${datasetName}.tables.json`);
+    return path.join(kanelTypesDir, `${datasetName}.tables.json`);
 }
 export function buildGeneratedTableManifest(datasetName, prefixedTables) {
     const manifest = {

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

@@ -1,3 +1,3 @@
-import type { Dataset } from "../../datasets.js";
+import type { Dataset } from "../../server/datasets.js";
 export declare function isCopyFromStdinLine(line: string): boolean;
 export declare function rewriteLineForStagingImport(line: string, dataset: Dataset, stagingSchema: string, inCopyData?: boolean): string;

package/lib/src/scripts/validate_prefixed_tables.js

@@ -1,21 +1,22 @@
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
-import { sql } from "../databases_postgres.js";
-import { getChosenDatasets, getEnabledDatasets } from "../datasets.js";
+import { sql } from "kysely";
+import { db } from "../server/databases_postgres.js";
+import { getChosenDatasets, getEnabledDatasets } from "../server/datasets.js";
 import { categoriesOption, silentOption } from "./shared/cli_helpers.js";
 import { extractPrefixedTableNamesFromGeneratedManifest, getGeneratedTableManifestPath, senatSchemaName, } from "./shared/prefixed_tables.js";
 const optionsDefinitions = [categoriesOption, silentOption];
 const options = commandLineArgs(optionsDefinitions);
 async function listPrefixedSenatTables(dataset) {
     const prefix = `${dataset.database}_`;
-    const rows = await sql `
-    select tablename as relation_name
+    const result = await sql `
+    select tablename
     from pg_tables
     where schemaname = ${senatSchemaName}
       and tablename like ${prefix + "%"}
     order by tablename
-  `;
-    return rows.map(({ relation_name }) => relation_name);
+  `.execute(db);
+    return result.rows.map(({ tablename }) => tablename);
 }
 function getGeneratedDefinitionPath(dataset) {
     return getGeneratedTableManifestPath(dataset.database);
@@ -26,14 +27,14 @@ function listExpectedPrefixedSenatTables(dataset) {
     return extractPrefixedTableNamesFromGeneratedManifest(manifest, dataset.database);
 }
 async function listColumns(schema, relationName) {
-    const rows = await sql `
+    const result = await sql `
     select column_name
     from information_schema.columns
     where table_schema = ${schema}
       and table_name = ${relationName}
     order by ordinal_position
-  `;
-    return rows.map(({ column_name }) => column_name);
+  `.execute(db);
+    return result.rows.map(({ column_name }) => column_name);
 }
 async function validateDataset(dataset) {
     const issues = [];
@@ -86,7 +87,7 @@ async function validatePrefixedTables() {
             console.error(`- ${issue}`);
         }
     }
-    await sql.end();
+    await db.destroy();
     if (hasErrors) {
         process.exit(1);
     }
@@ -95,7 +96,7 @@ async function validatePrefixedTables() {
     }
 }
 validatePrefixedTables().catch(async (error) => {
-    await sql.end();
+    await db.destroy();
     console.error(error);
     process.exit(1);
 });