@proofgeist/fmdapi/dist/utils/typegen/buildLayoutClient.js

FileMaker Data API client

import { CodeBlockWriter, SourceFile, VariableDeclarationKind } from "ts-morph";
import {} from "./types.js";
import { isOttoAuth } from "../../adapters/otto.js";
export function buildLayoutClient(sourceFile, args) {
    const { schemaName, portalSchema, envNames, type, webviewerScriptName, layoutName, } = args;
    const fmdapiImport = sourceFile.addImportDeclaration({
        moduleSpecifier: "@proofgeist/fmdapi",
        namedImports: ["DataApi"],
    });
    const hasPortals = (portalSchema ?? []).length > 0;
    if (webviewerScriptName) {
        sourceFile.addImportDeclaration({
            moduleSpecifier: `@proofgeist/fm-webviewer-fetch/adapter`,
            namedImports: ["WebViewerAdapter"],
        });
    }
    else if (isOttoAuth(envNames.auth)) {
        // if otto, add the OttoAdapter and OttoAPIKey imports
        fmdapiImport.addNamedImports([
            { name: "OttoAdapter" },
            { name: "OttoAPIKey", isTypeOnly: true },
        ]);
    }
    else {
        fmdapiImport.addNamedImport({ name: "FetchAdapter" });
    }
    // import the types
    const schemaImport = sourceFile.addImportDeclaration({
        moduleSpecifier: `../${schemaName}`,
        namedImports: [{ name: `T${schemaName}`, isTypeOnly: true }],
    });
    if (type === "zod")
        schemaImport.addNamedImport(`Z${schemaName}`);
    // add portal imports
    if (hasPortals) {
        schemaImport.addNamedImport({
            name: `T${schemaName}Portals`,
            isTypeOnly: true,
        });
        if (type === "zod")
            schemaImport.addNamedImport(`Z${schemaName}Portals`);
    }
    if (!webviewerScriptName) {
        addTypeGuardStatements(sourceFile, { envVarName: envNames.db });
        addTypeGuardStatements(sourceFile, { envVarName: envNames.server });
        if (isOttoAuth(envNames.auth)) {
            addTypeGuardStatements(sourceFile, { envVarName: envNames.auth.apiKey });
        }
        else {
            addTypeGuardStatements(sourceFile, {
                envVarName: envNames.auth.username,
            });
            addTypeGuardStatements(sourceFile, {
                envVarName: envNames.auth.password,
            });
        }
    }
    sourceFile.addVariableStatement({
        declarationKind: VariableDeclarationKind.Const,
        isExported: true,
        declarations: [
            {
                name: "client",
                initializer: (writer) => {
                    writer
                        .write(`DataApi<any, T${schemaName}${hasPortals ? `, T${schemaName}Portals` : ""}>(`)
                        .inlineBlock(() => {
                        writer.write(`adapter: `);
                        buildAdapter(writer, args);
                        writer.write(",").newLine();
                        writer.write(`layout: `).quote(layoutName).write(`,`).newLine();
                        if (type === "zod") {
                            writer.writeLine(`zodValidators: { fieldData: Z${schemaName}${hasPortals ? `, portalData: Z${schemaName}Portals` : ""} },`);
                        }
                    })
                        .write(")");
                },
            },
        ],
    });
    //   sourceFile.addExportAssignment({ isExportEquals: true, expression: "" });
}
function addTypeGuardStatements(sourceFile, { envVarName }) {
    sourceFile.addStatements((writer) => {
        writer.writeLine(`if (!process.env.${envVarName}) throw new Error("Missing env var: ${envVarName}")`);
    });
}
function buildAdapter(writer, args) {
    const { envNames, webviewerScriptName } = args;
    if (webviewerScriptName) {
        writer.write(`new WebViewerAdapter({scriptName: `);
        writer.quote(webviewerScriptName);
        writer.write("})");
    }
    else if (isOttoAuth(envNames.auth)) {
        writer
            .write(`new OttoAdapter(`)
            .inlineBlock(() => {
            if (!isOttoAuth(envNames.auth))
                return;
            writer
                .write(`auth: { apiKey: process.env.${envNames.auth.apiKey} as OttoAPIKey }`)
                .write(",")
                .newLine();
            writer.write(`db: process.env.${envNames.db}`).write(",").newLine();
            writer
                .write(`server: process.env.${envNames.server}`)
                .write(",")
                .newLine();
        })
            .write(`)`);
    }
    else {
        writer
            .write(`new FetchAdapter(`)
            .inlineBlock(() => {
            if (isOttoAuth(envNames.auth))
                return;
            writer
                .writeLine(`auth:`)
                .inlineBlock(() => {
                if (isOttoAuth(envNames.auth))
                    return;
                writer
                    .write(`username: process.env.${envNames.auth.username}`)
                    .write(",")
                    .newLine();
                writer.write(`password: process.env.${envNames.auth.password}`);
            })
                .write(",")
                .writeLine(`db: process.env.${envNames.db},`)
                .writeLine(`server: process.env.${envNames.server}`);
        })
            .write(")");
    }
    return writer.toString();
}
//# sourceMappingURL=buildLayoutClient.js.map