@nestia/sdk/lib/generates/internal/SdkDistributionComposer.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());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SdkDistributionComposer = void 0;
const child_process_1 = __importDefault(require("child_process"));
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
var SdkDistributionComposer;
(function (SdkDistributionComposer) {
    SdkDistributionComposer.compose = (props) => __awaiter(this, void 0, void 0, function* () {
        if (!fs_1.default.existsSync(props.config.distribute))
            yield fs_1.default.promises.mkdir(props.config.distribute, { recursive: true });
        const root = process.cwd();
        const output = path_1.default.resolve(props.config.output);
        process.chdir(props.config.distribute);
        try {
            if (yield configured())
                return;
            // COPY FILES
            console.log("Composing SDK distribution environments...");
            for (const file of yield fs_1.default.promises.readdir(BUNDLE))
                yield fs_1.default.promises.copyFile(`${BUNDLE}/${file}`, file);
            // CONFIGURE PATHS
            for (const file of ["package.json", "tsconfig.json"])
                yield replace({ root, output })(file);
            // INSTALL PACKAGES
            const v = yield dependencies({
                websocket: props.websocket,
            });
            execute("npm install --save-dev rimraf");
            execute(`npm install --save @nestia/fetcher@${v.version}`);
            execute(`npm install --save typia@${v.typia}`);
            if (props.mcp && v.mcp !== undefined)
                execute(`npm install --save @modelcontextprotocol/sdk@${v.mcp}`);
            if (props.websocket && v.tgrid !== undefined)
                execute(`npm install --save tgrid@${v.tgrid}`);
            execute("npx typia setup --manager npm");
        }
        finally {
            process.chdir(root);
        }
    });
    const configured = () => __awaiter(this, void 0, void 0, function* () {
        return ["package.json", "tsconfig.json"].every(fs_1.default.existsSync) &&
            (yield (() => __awaiter(this, void 0, void 0, function* () {
                var _a;
                const content = JSON.parse(yield fs_1.default.promises.readFile("package.json", "utf8"));
                return !!((_a = content.dependencies) === null || _a === void 0 ? void 0 : _a["@nestia/fetcher"]);
            }))());
    });
    const execute = (command) => {
        console.log(`  - ${command}`);
        child_process_1.default.execSync(command, { stdio: "ignore" });
    };
    const replace = (props) => (file) => __awaiter(this, void 0, void 0, function* () {
        const relative = (from) => (to) => path_1.default.relative(from, to).split("\\").join("/");
        const root = relative(process.cwd())(props.root);
        const output = relative(process.cwd())(props.output);
        const current = relative(props.root)(process.cwd());
        const content = yield fs_1.default.promises.readFile(file, "utf8");
        yield fs_1.default.promises.writeFile(file, content
            .split("${root}")
            .join(root)
            .split("${output}")
            .join(output)
            .split("${current}")
            .join(current), "utf8");
    });
    const dependencies = (opts) => __awaiter(this, void 0, void 0, function* () {
        const content = yield fs_1.default.promises.readFile(__dirname + "/../../../package.json", "utf8");
        const json = JSON.parse(content);
        const dependencies = Object.assign(Object.assign({}, json.devDependencies), json.dependencies);
        const required = (key) => {
            const value = key === "version" ? json.version : dependencies[key];
            if (typeof value !== "string" || value.length === 0)
                throw new Error(`Unable to resolve ${key} version for SDK distribution.`);
            return value;
        };
        return {
            version: required("version"),
            typia: required("typia"),
            tgrid: opts.websocket ? dependencies.tgrid : undefined,
            mcp: dependencies["@modelcontextprotocol/sdk"],
        };
    });
})(SdkDistributionComposer || (exports.SdkDistributionComposer = SdkDistributionComposer = {}));
const BUNDLE = __dirname + "/../../../assets/bundle/distribute";
//# sourceMappingURL=SdkDistributionComposer.js.map