kanel-knex/build/generateKnexTablesModule.js

Knex extension for Kanel

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const kanel_1 = require("kanel");
const path_1 = require("path");
function getAsName(typeMetadata, schemaName) {
    return schemaName === "public"
        ? undefined
        : `${schemaName}_${typeMetadata.name}`;
}
const getTypeImports = (details, context) => {
    const { getMetadata } = context;
    const selector = getMetadata(details, "selector");
    const result = [
        {
            name: selector.name,
            asName: getAsName(selector, details.schemaName),
            isDefault: true,
            path: selector.path,
            isAbsolute: false,
            importAsType: true,
        },
    ];
    const isReadonly = details.kind !== "table";
    if (!isReadonly) {
        const initializer = getMetadata(details, "initializer");
        result.push({
            name: initializer.name,
            asName: getAsName(initializer, details.schemaName),
            isDefault: false,
            path: initializer.path,
            isAbsolute: false,
            importAsType: true,
        });
        const mutator = getMetadata(details, "mutator");
        result.push({
            name: mutator.name,
            asName: getAsName(mutator, details.schemaName),
            isDefault: false,
            path: mutator.path,
            isAbsolute: false,
            importAsType: true,
        });
    }
    return result;
};
const getLine = (details, context) => {
    const { getMetadata } = context;
    const selector = getMetadata(details, "selector");
    const selectorName = getAsName(selector, details.schemaName) ?? selector.name;
    let initializerName = "never";
    let mutatorName = "never";
    const isReadonly = details.kind !== "table";
    if (!isReadonly) {
        const initializer = getMetadata(details, "initializer");
        initializerName =
            getAsName(initializer, details.schemaName) ?? initializer.name;
        const mutator = getMetadata(details, "mutator");
        mutatorName = getAsName(mutator, details.schemaName) ?? mutator.name;
    }
    const name = details.schemaName === "public"
        ? details.name
        : `${details.schemaName}.${details.name}`;
    return `    '${name}': Knex.CompositeTableType<${selectorName}, ${initializerName}, ${mutatorName}>;`;
};
const generateKnexTablesModule = async (outputAcc, context) => {
    const { schemas, config } = (0, kanel_1.useKanelContext)();
    const typeImports = Object.values(schemas).reduce((acc, schema) => {
        const tableTypeImports = schema.tables
            .sort((a, b) => a.name.localeCompare(b.name))
            .map((table) => getTypeImports(table, context));
        const viewTypeImports = schema.views
            .sort((a, b) => a.name.localeCompare(b.name))
            .map((view) => getTypeImports(view, context));
        const materializedViewTypeImports = schema.materializedViews
            .sort((a, b) => a.name.localeCompare(b.name))
            .map((materializedView) => getTypeImports(materializedView, context));
        return [
            ...acc,
            ...tableTypeImports.flat(),
            ...viewTypeImports.flat(),
            ...materializedViewTypeImports.flat(),
        ];
    }, [
        {
            name: "Knex",
            isAbsolute: true,
            path: "knex",
            isDefault: false,
            importAsType: false,
        },
    ]);
    const declarationLines = Object.values(schemas).reduce((acc, schema) => {
        const tableLines = schema.tables.map((table) => getLine(table, context));
        const viewLines = schema.views.map((view) => getLine(view, context));
        const materializedViewLines = schema.materializedViews.map((materializedView) => getLine(materializedView, context));
        return [...acc, ...tableLines, ...viewLines, ...materializedViewLines];
    }, []);
    const lines = [
        "declare module 'knex/types/tables' {",
        "  interface Tables {",
        ...declarationLines,
        "  }",
        "}",
    ];
    const declaration = {
        declarationType: "generic",
        typeImports,
        lines,
    };
    const outputPath = config.outputPath ?? "";
    const path = (0, path_1.join)(outputPath, "knex-tables");
    return {
        ...outputAcc,
        [path]: { fileType: "typescript", declarations: [declaration] },
    };
};
exports.default = generateKnexTablesModule;