stackkit-cli 0.4.4 → 0.4.5

package/dist/utils/js-conversion.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToJavaScript = convertToJavaScript;
+/* eslint-disable @typescript-eslint/no-require-imports */
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const baseDirs = {
+    express: "./src",
+    "react-vite": "./src",
+    nextjs: ".",
+};
+async function convertToJavaScript(targetDir, framework) {
+    const tsFiles = [
+        "tsconfig.json",
+        "tsconfig.app.json",
+        "tsconfig.node.json",
+        "next-env.d.ts",
+        "vite-env.d.ts",
+    ];
+    for (const file of tsFiles) {
+        const filePath = path_1.default.join(targetDir, file);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            await fs_extra_1.default.remove(filePath);
+        }
+    }
+    const removeDtsFiles = async (dir) => {
+        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== "node_modules") {
+                await removeDtsFiles(fullPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".d.ts")) {
+                await fs_extra_1.default.remove(fullPath);
+            }
+        }
+    };
+    await removeDtsFiles(targetDir);
+    const babel = require("@babel/core");
+    const transpileAllTsFiles = async (dir) => {
+        const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== "node_modules") {
+                await transpileAllTsFiles(fullPath);
+            }
+            else if (entry.isFile()) {
+                if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+                    const code = await fs_extra_1.default.readFile(fullPath, "utf8");
+                    const isTsx = entry.name.endsWith(".tsx");
+                    const outFile = fullPath.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
+                    const presets = [
+                        [
+                            require.resolve("@babel/preset-typescript"),
+                            {
+                                onlyRemoveTypeImports: true,
+                                allowDeclareFields: true,
+                                allowNamespaces: true,
+                                optimizeForSpeed: true,
+                                allExtensions: true,
+                                isTSX: isTsx,
+                            },
+                        ],
+                        [
+                            require.resolve("@babel/preset-env"),
+                            {
+                                targets: { node: "18" },
+                                modules: false,
+                            },
+                        ],
+                    ];
+                    if (isTsx) {
+                        presets.push([
+                            require.resolve("@babel/preset-react"),
+                            {
+                                runtime: "classic",
+                            },
+                        ]);
+                    }
+                    // Use recast + Babel AST transform (same approach as transform.tools)
+                    try {
+                        const recast = require("recast");
+                        const { transformFromAstSync } = require("@babel/core");
+                        const transformTypescript = require("@babel/plugin-transform-typescript");
+                        // getBabelOptions may be exported as default or directly
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        let getBabelOptions = require("recast/parsers/_babel_options");
+                        if (getBabelOptions && getBabelOptions.default)
+                            getBabelOptions = getBabelOptions.default;
+                        const babelParser = require("recast/parsers/babel").parser;
+                        const ast = recast.parse(code, {
+                            parser: {
+                                parse: (source, options) => {
+                                    const babelOptions = getBabelOptions(options || {});
+                                    // ensure typescript and jsx handling
+                                    if (isTsx) {
+                                        babelOptions.plugins.push("typescript", "jsx");
+                                    }
+                                    else {
+                                        babelOptions.plugins.push("typescript");
+                                    }
+                                    return babelParser.parse(source, babelOptions);
+                                },
+                            },
+                        });
+                        const opts = {
+                            cloneInputAst: false,
+                            code: false,
+                            ast: true,
+                            plugins: [transformTypescript],
+                            configFile: false,
+                        };
+                        const { ast: transformedAST } = transformFromAstSync(ast, code, opts);
+                        const resultCode = recast.print(transformedAST).code;
+                        await fs_extra_1.default.writeFile(outFile, resultCode, "utf8");
+                        await fs_extra_1.default.remove(fullPath);
+                        continue;
+                    }
+                    catch {
+                        // ignore recast errors, fall back to babel
+                    }
+                    const result = await babel.transformAsync(code, {
+                        filename: entry.name,
+                        presets,
+                        comments: true,
+                        retainLines: true,
+                        compact: false,
+                        babelrc: false,
+                        configFile: false,
+                    });
+                    await fs_extra_1.default.writeFile(outFile, result.code, "utf8");
+                    await fs_extra_1.default.remove(fullPath);
+                }
+            }
+        }
+    };
+    await transpileAllTsFiles(targetDir);
+    const baseDir = baseDirs[framework];
+    if (baseDir) {
+        const replaceAliases = async (dir) => {
+            const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = path_1.default.join(dir, entry.name);
+                if (entry.isDirectory() && entry.name !== "node_modules") {
+                    await replaceAliases(full);
+                }
+                else if (entry.isFile() && (entry.name.endsWith(".js") || entry.name.endsWith(".jsx"))) {
+                    const content = await fs_extra_1.default.readFile(full, "utf-8");
+                    if (content.includes("@/")) {
+                        const fileDir = path_1.default.dirname(full);
+                        const newContent = content.replace(/from ['"]@\/([^'"]*)['"]/g, (match, p1) => {
+                            const resolved = path_1.default.resolve(baseDir, p1);
+                            let relPath = path_1.default.relative(fileDir, resolved);
+                            if (!relPath.startsWith("."))
+                                relPath = "./" + relPath;
+                            return `from '${relPath}'`;
+                        });
+                        await fs_extra_1.default.writeFile(full, newContent, "utf-8");
+                    }
+                }
+            }
+        };
+        await replaceAliases(targetDir);
+    }
+    const templatesRoot = path_1.default.join(__dirname, "..", "..", "..", "templates");
+    const templateName = framework;
+    let fileReplacements = [];
+    let jsScripts = null;
+    if (templateName) {
+        const templateJsonPath = path_1.default.join(templatesRoot, templateName, "template.json");
+        if (await fs_extra_1.default.pathExists(templateJsonPath)) {
+            try {
+                const templateJson = await fs_extra_1.default.readJson(templateJsonPath);
+                if (Array.isArray(templateJson.fileReplacements)) {
+                    fileReplacements = templateJson.fileReplacements;
+                }
+                if (templateJson.jsScripts) {
+                    jsScripts = templateJson.jsScripts;
+                }
+            }
+            catch {
+                // ignore errors reading template.json
+            }
+        }
+    }
+    for (const rep of fileReplacements) {
+        const filePath = path_1.default.join(targetDir, rep.file);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            let content = await fs_extra_1.default.readFile(filePath, "utf8");
+            if (rep.from && rep.to) {
+                content = content.replace(rep.from, rep.to);
+                await fs_extra_1.default.writeFile(filePath, content, "utf8");
+            }
+        }
+    }
+    if (jsScripts) {
+        const packageJsonPath = path_1.default.join(targetDir, "package.json");
+        if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+            const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+            packageJson.scripts = { ...packageJson.scripts, ...jsScripts };
+            await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+        }
+    }
+    const jsconfig = path_1.default.join(targetDir, "jsconfig.json");
+    if (!(await fs_extra_1.default.pathExists(jsconfig))) {
+        for (const tmpl of await fs_extra_1.default.readdir(templatesRoot, { withFileTypes: true })) {
+            if (tmpl.isDirectory()) {
+                const templateJsconfig = path_1.default.join(templatesRoot, tmpl.name, "jsconfig.json");
+                if (await fs_extra_1.default.pathExists(templateJsconfig)) {
+                    await fs_extra_1.default.copy(templateJsconfig, jsconfig);
+                    break;
+                }
+            }
+        }
+    }
+    const srcDir = path_1.default.join(targetDir, "src");
+    if (await fs_extra_1.default.pathExists(srcDir)) {
+        const srcFiles = await fs_extra_1.default.readdir(srcDir);
+        for (const file of srcFiles) {
+            if ((file.endsWith(".js") || file.endsWith(".jsx")) &&
+                file.replace(/\.(js|jsx)$/, ".ts") &&
+                srcFiles.includes(file.replace(/\.(js|jsx)$/, ".ts"))) {
+                await fs_extra_1.default.remove(path_1.default.join(srcDir, file.replace(/\.(js|jsx)$/, ".ts")));
+            }
+            if (file.endsWith(".jsx") && srcFiles.includes(file.replace(/\.jsx$/, ".tsx"))) {
+                await fs_extra_1.default.remove(path_1.default.join(srcDir, file.replace(/\.jsx$/, ".tsx")));
+            }
+        }
+    }
+    const packageJsonPath = path_1.default.join(targetDir, "package.json");
+    if (await fs_extra_1.default.pathExists(packageJsonPath)) {
+        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+        if (packageJson.devDependencies) {
+            delete packageJson.devDependencies["typescript"];
+            delete packageJson.devDependencies["@types/node"];
+            delete packageJson.devDependencies["@types/react"];
+            delete packageJson.devDependencies["@types/react-dom"];
+        }
+        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+    }
+}

package/dist/utils/module-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeDatabaseConfig(templatesDir: string, targetDir: string, database: string, framework: string, dbProvider?: string): Promise<string[]>;
+export declare function mergeAuthConfig(templatesDir: string, targetDir: string, framework: string, auth: string, database?: string, dbProvider?: string): Promise<void>;