@nestia/sdk/lib/generates/internal/E2eFileProgrammer.js

Nestia SDK and Swagger generator

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.E2eFileProgrammer = void 0;
const factory_1 = require("@ttsc/factory");
const IdentifierFactory_1 = require("../../factories/IdentifierFactory");
const LiteralFactory_1 = require("../../factories/LiteralFactory");
const FilePrinter_1 = require("./FilePrinter");
const ImportDictionary_1 = require("./ImportDictionary");
const SdkAliasCollection_1 = require("./SdkAliasCollection");
const SdkHttpParameterProgrammer_1 = require("./SdkHttpParameterProgrammer");
const SdkImportWizard_1 = require("./SdkImportWizard");
var E2eFileProgrammer;
(function (E2eFileProgrammer) {
    E2eFileProgrammer.generate = (project) => (props) => (route) => __awaiter(this, void 0, void 0, function* () {
        const importer = new ImportDictionary_1.ImportDictionary(`${props.current}/${getFunctionName(route)}.ts`);
        if (project.config.clone !== true)
            importer.declarations(route.imports);
        importer.internal({
            file: props.api,
            declaration: false,
            type: "default",
            name: "api",
        });
        const functor = generateFunctor(project)(importer)(route);
        yield FilePrinter_1.FilePrinter.write({
            location: importer.file,
            statements: [
                ...importer.toStatements(props.current),
                FilePrinter_1.FilePrinter.enter(),
                functor,
            ],
        });
    });
    const generateFunctor = (project) => (importer) => (route) => factory_1.factory.createVariableStatement([factory_1.factory.createModifier(factory_1.SyntaxKind.ExportKeyword)], factory_1.factory.createVariableDeclarationList([
        factory_1.factory.createVariableDeclaration(factory_1.factory.createIdentifier(getFunctionName(route)), undefined, undefined, generateArrow(project)(importer)(route)),
    ], factory_1.NodeFlags.Const));
    const generateArrow = (project) => (importer) => (route) => {
        const random = IdentifierFactory_1.IdentifierFactory.access(factory_1.factory.createIdentifier(SdkImportWizard_1.SdkImportWizard.typia(importer)), "random");
        const connection = route.headerObject
            ? factory_1.factory.createObjectLiteralExpression([
                factory_1.factory.createSpreadAssignment(factory_1.factory.createIdentifier("connection")),
                factory_1.factory.createPropertyAssignment("headers", factory_1.factory.createObjectLiteralExpression([
                    factory_1.factory.createSpreadAssignment(IdentifierFactory_1.IdentifierFactory.access(factory_1.factory.createIdentifier("connection"), "headers")),
                    factory_1.factory.createSpreadAssignment(factory_1.factory.createCallExpression(random, [
                        (project.config.clone === true
                            ? SdkAliasCollection_1.SdkAliasCollection.from(project)(importer)(route.headerObject.metadata)
                            : SdkAliasCollection_1.SdkAliasCollection.name(route.headerObject)),
                    ], undefined)),
                ], true)),
            ], true)
            : factory_1.factory.createIdentifier("connection");
        const entries = SdkHttpParameterProgrammer_1.SdkHttpParameterProgrammer.getEntries({
            project,
            importer,
            route,
            body: true,
            e2e: true,
            prefix: ["api", "functional", ...route.accessor].join(".") + ".",
        });
        const fetch = factory_1.factory.createCallExpression(factory_1.factory.createIdentifier(["api", "functional", ...route.accessor].join(".")), undefined, [
            connection,
            ...(project.config.keyword === true && entries.length !== 0
                ? [
                    LiteralFactory_1.LiteralFactory.write(Object.fromEntries(entries.map((e) => [
                        e.key,
                        factory_1.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(factory_1.factory.createIdentifier(SdkImportWizard_1.SdkImportWizard.typia(importer)), "random"), [getRandomType(importer)(e)], undefined),
                    ]))),
                ]
                : entries.map((e) => factory_1.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(factory_1.factory.createIdentifier(SdkImportWizard_1.SdkImportWizard.typia(importer)), "random"), [getRandomType(importer)(e)], undefined))),
        ]);
        const assert = factory_1.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(factory_1.factory.createIdentifier(SdkImportWizard_1.SdkImportWizard.typia(importer)), "assert"), undefined, [factory_1.factory.createIdentifier("output")]);
        return factory_1.factory.createArrowFunction([factory_1.factory.createModifier(factory_1.SyntaxKind.AsyncKeyword)], undefined, [
            IdentifierFactory_1.IdentifierFactory.parameter("connection", factory_1.factory.createTypeReferenceNode("api.IConnection")),
        ], undefined, undefined, factory_1.factory.createBlock([
            factory_1.factory.createVariableStatement([], factory_1.factory.createVariableDeclarationList([
                factory_1.factory.createVariableDeclaration("output", undefined, project.config.propagate !== true &&
                    route.success.type.name === "void"
                    ? undefined
                    : SdkAliasCollection_1.SdkAliasCollection.response(project)(importer)(route), factory_1.factory.createAwaitExpression(fetch)),
            ], factory_1.NodeFlags.Const)),
            ...(route.success.binary === true
                ? []
                : [factory_1.factory.createExpressionStatement(assert)]),
        ]));
    };
})(E2eFileProgrammer || (exports.E2eFileProgrammer = E2eFileProgrammer = {}));
const getRandomType = (importer) => (entry) => {
    if (isPlainStringPathParameter(entry) === false)
        return entry.type;
    return factory_1.factory.createIntersectionTypeNode([
        entry.type,
        factory_1.factory.createTypeReferenceNode(factory_1.factory.createQualifiedName(factory_1.factory.createIdentifier(importer.external({
            declaration: true,
            file: "typia",
            type: "element",
            name: "tags",
        })), factory_1.factory.createIdentifier("MinLength")), [
            factory_1.factory.createLiteralTypeNode(LiteralFactory_1.LiteralFactory.write(1)),
        ]),
    ]);
};
const isPlainStringPathParameter = (entry) => entry.parameter.category === "param" &&
    entry.parameter.metadata.atomics.length === 1 &&
    entry.parameter.metadata.atomics[0].type === "string" &&
    entry.parameter.metadata.atomics[0].tags.every((row) => row.every((tag) => tag.kind !== "minLength"));
const getFunctionName = (route) => ["test", "api", ...route.accessor].join("_");
//# sourceMappingURL=E2eFileProgrammer.js.map