kanel-kysely/build/makeKyselyHook.js

Kysely extension for Kanel

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const recase_1 = require("@kristiandupont/recase");
const kanel_1 = require("kanel");
const path_1 = require("path");
const MakeKyselyConfig_1 = require("./MakeKyselyConfig");
const processFile_1 = __importDefault(require("./processFile"));
const toPascalCase = (0, recase_1.recase)(null, "pascal");
const makeKyselyHook = (makeKyselyConfig_) => async (outputAcc, pgTsContext) => {
    const { schemas, config } = (0, kanel_1.useKanelContext)();
    const makeKyselyConfig = {
        ...MakeKyselyConfig_1.defaultConfig,
        ...makeKyselyConfig_,
    };
    const output = { ...outputAcc };
    const schemaImports = [];
    for (const schemaName of Object.keys(schemas)) {
        const schema = schemas[schemaName];
        const composites = [
            ...(schema.tables ?? []),
            ...(schema.views ?? []),
            ...(schema.materializedViews ?? []),
            ...(schema.compositeTypes ?? []),
        ];
        if (composites.length === 0) {
            continue;
        }
        // Get the schema folder from the first known composite.
        let schemaFolder;
        const tableImports = [];
        const tableProps = [];
        composites.forEach((compositeDetails) => {
            const { path } = pgTsContext.getMetadata(compositeDetails, "selector");
            if (output[path].fileType !== "typescript") {
                throw new Error(`Path ${path} is not a typescript file`);
            }
            const { modifiedDeclarations, tableImport, tableProperty } = (0, processFile_1.default)(output[path].declarations, compositeDetails, path, makeKyselyConfig, pgTsContext);
            output[path].declarations = modifiedDeclarations;
            if (makeKyselyConfig.includeSchemaNameInTableName)
                tableProperty.name = `${schemaName}.${tableProperty.name}`;
            tableImports.push(tableImport);
            tableProps.push(tableProperty);
            if (!schemaFolder) {
                schemaFolder = (0, path_1.dirname)(path);
            }
        });
        const schemaInterfaceName = `${toPascalCase(schemaName)}Schema`;
        const schemaDeclaration = {
            declarationType: "interface",
            name: schemaInterfaceName,
            exportAs: "default",
            typeImports: tableImports,
            properties: tableProps,
        };
        const schemaPath = (0, path_1.join)(schemaFolder, schemaInterfaceName);
        output[schemaPath] = {
            fileType: "typescript",
            declarations: [schemaDeclaration],
        };
        const schemaImport = {
            name: schemaInterfaceName,
            asName: undefined,
            isDefault: true,
            path: schemaPath,
            isAbsolute: false,
            importAsType: true,
        };
        schemaImports.push(schemaImport);
    }
    const dbPath = (0, path_1.join)(config.outputPath ?? ".", makeKyselyConfig.databaseFilename);
    const dbDeclaration = {
        declarationType: "typeDeclaration",
        name: "Database",
        typeImports: schemaImports,
        typeDefinition: [
            schemaImports.map((dbImport) => dbImport.name).join(" & "),
        ],
        exportAs: "default",
    };
    output[dbPath] = {
        fileType: "typescript",
        declarations: [dbDeclaration],
    };
    return output;
};
exports.default = makeKyselyHook;