stackkit-cli 0.4.3 → 0.4.5

package/dist/types/index.d.ts

@@ -12,10 +12,37 @@ export interface ModuleMetadata {
     description: string;
     category: "auth" | "database" | "ui" | "other";
     supportedFrameworks: string[];
-    dependencies: Record<string, string>;
-    devDependencies?: Record<string, string>;
+    dependencies: {
+        common?: Record<string, string>;
+        providers?: Record<string, Record<string, string>>;
+    } | Record<string, string>;
+    devDependencies?: {
+        common?: Record<string, string>;
+        providers?: Record<string, Record<string, string>>;
+    } | Record<string, string>;
     envVars: EnvVar[];
     patches: ModulePatch[];
+    frameworkPatches?: Record<string, {
+        [file: string]: {
+            merge?: Record<string, unknown>;
+        };
+    }>;
+    postInstall?: string[];
+    databaseAdapters?: {
+        common?: {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        };
+        providers?: Record<string, Record<string, {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        }>>;
+    };
+    frameworkConfigs?: Record<string, {
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+        patches?: ModulePatch[];
+    }>;
 }
 export interface EnvVar {
     key: string;

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

@@ -0,0 +1,2 @@
+export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;
+export declare function applyFrameworkPatches(targetDir: string, patches: Record<string, unknown>): Promise<void>;

package/dist/utils/config-utils.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+exports.applyFrameworkPatches = applyFrameworkPatches;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+            result[key] = deepMerge(result[key] || {}, source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}
+async function applyFrameworkPatches(targetDir, patches) {
+    for (const [filename, patchConfig] of Object.entries(patches)) {
+        const filePath = (0, path_1.join)(targetDir, filename);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            if (patchConfig && typeof patchConfig === "object" && "merge" in patchConfig) {
+                const fileContent = await fs_extra_1.default.readJson(filePath);
+                const merged = deepMerge(fileContent, patchConfig.merge);
+                await fs_extra_1.default.writeJson(filePath, merged, { spaces: 2 });
+            }
+            else if (patchConfig && typeof patchConfig === "object" && "replace" in patchConfig) {
+                let fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+                const replaceConfig = patchConfig;
+                for (const [oldStr, newStr] of Object.entries(replaceConfig.replace)) {
+                    fileContent = fileContent.replace(new RegExp(oldStr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newStr);
+                }
+                await fs_extra_1.default.writeFile(filePath, fileContent);
+            }
+            else if (patchConfig &&
+                typeof patchConfig === "object" &&
+                ("operations" in patchConfig ||
+                    ("type" in patchConfig && patchConfig.type === "patch-file"))) {
+                let fileContent = await fs_extra_1.default.readFile(filePath, "utf-8");
+                const operations = patchConfig.operations;
+                for (const operation of operations) {
+                    if (operation && typeof operation === "object" && "type" in operation) {
+                        const op = operation;
+                        if (op.type === "add-import" && "imports" in op && Array.isArray(op.imports)) {
+                            const imports = op.imports;
+                            // Add imports at the top after existing imports
+                            const importLines = imports.join("\n");
+                            // Find the last import statement
+                            const lines = fileContent.split("\n");
+                            let lastImportIndex = -1;
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].trim().startsWith("import")) {
+                                    lastImportIndex = i;
+                                }
+                                else if (lines[i].trim() !== "" && !lines[i].trim().startsWith("//")) {
+                                    break;
+                                }
+                            }
+                            if (lastImportIndex >= 0) {
+                                lines.splice(lastImportIndex + 1, 0, "", importLines);
+                                fileContent = lines.join("\n");
+                            }
+                        }
+                        else if (op.type === "add-code" && "after" in op && "code" in op) {
+                            const after = op.after;
+                            const code = op.code;
+                            const afterIndex = fileContent.indexOf(after);
+                            if (afterIndex >= 0) {
+                                const insertPos = afterIndex + after.length;
+                                fileContent = fileContent.slice(0, insertPos) + code + fileContent.slice(insertPos);
+                            }
+                        }
+                        else if (op.type === "replace" && "oldString" in op && "newString" in op) {
+                            const oldString = op.oldString;
+                            const newString = op.newString;
+                            fileContent = fileContent.replace(oldString, newString);
+                        }
+                    }
+                }
+                await fs_extra_1.default.writeFile(filePath, fileContent);
+            }
+        }
+    }
+}

package/dist/utils/detect.js

@@ -54,7 +54,18 @@ async function detectProjectInfo(targetDir) {
     }
     // Detect TypeScript vs JavaScript
     const tsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "tsconfig.json"));
-    const language = tsconfigExists ? "ts" : "js";
+    const jsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "jsconfig.json"));
+    let language;
+    if (tsconfigExists) {
+        language = "ts";
+    }
+    else if (jsconfigExists) {
+        language = "js";
+    }
+    else {
+        // Default to TypeScript if neither exists
+        language = "ts";
+    }
     // Detect package manager
     const yarnLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "yarn.lock"));
     const pnpmLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "pnpm-lock.yaml"));
@@ -73,7 +84,6 @@ async function detectProjectInfo(targetDir) {
     const hasAuth = !!(packageJson.dependencies?.["next-auth"] ||
         packageJson.dependencies?.["better-auth"] ||
         packageJson.dependencies?.["@auth/core"] ||
-        packageJson.dependencies?.["@clerk/nextjs"] ||
         packageJson.dependencies?.["@kinde-oss/kinde-auth-nextjs"] ||
         packageJson.dependencies?.["passport"]);
     const hasPrisma = !!(packageJson.dependencies?.["@prisma/client"] || packageJson.devDependencies?.["prisma"]);

package/dist/utils/env-editor.d.ts

@@ -1,7 +1,6 @@
 export interface EnvVariable {
     key: string;
     value?: string;
-    description: string;
     required: boolean;
 }
 export declare function addEnvVariables(projectRoot: string, variables: EnvVariable[], options?: {

package/dist/utils/env-editor.js

@@ -13,9 +13,7 @@ const ENV_MARKER_END = "# End StackKit";
 async function addEnvVariables(projectRoot, variables, options = {}) {
     const envExamplePath = path_1.default.join(projectRoot, ".env.example");
     const envPath = path_1.default.join(projectRoot, ".env");
-    // Add to .env.example
     await appendToEnvFile(envExamplePath, variables, "example", options);
-    // Add to .env if it exists or create it
     const envExists = await fs_extra_1.default.pathExists(envPath);
     if (envExists || options.force) {
         await appendToEnvFile(envPath, variables, "local", options);
@@ -23,11 +21,28 @@ async function addEnvVariables(projectRoot, variables, options = {}) {
     logger_1.logger.success("Environment variables added");
 }
 async function appendToEnvFile(filePath, variables, fileType, options = {}) {
+    // Validate environment variable keys
+    for (const variable of variables) {
+        if (!/^[A-Z_][A-Z0-9_]*$/.test(variable.key)) {
+            throw new Error(`Invalid environment variable key: ${variable.key}`);
+        }
+    }
     let content = "";
     if (await fs_extra_1.default.pathExists(filePath)) {
         content = await fs_extra_1.default.readFile(filePath, "utf-8");
     }
-    // Check if variables already exist
+    // If force, remove existing keys first to avoid duplicates
+    if (options.force) {
+        const keysToRemove = variables.map((v) => v.key);
+        await removeFromEnvFile(filePath, keysToRemove);
+        if (await fs_extra_1.default.pathExists(filePath)) {
+            content = await fs_extra_1.default.readFile(filePath, "utf-8");
+        }
+        else {
+            content = "";
+        }
+    }
+    // Check if variables already exist (after potential removal)
     const existingKeys = new Set();
     const lines = content.split("\n");
     for (const line of lines) {
@@ -36,15 +51,7 @@ async function appendToEnvFile(filePath, variables, fileType, options = {}) {
             existingKeys.add(match[1]);
         }
     }
-    const newVariables = variables.filter((v) => {
-        if (existingKeys.has(v.key)) {
-            if (!options.force) {
-                logger_1.logger.warn(`Variable ${v.key} already exists in ${filePath}`);
-                return false;
-            }
-        }
-        return true;
-    });
+    const newVariables = variables.filter((v) => !existingKeys.has(v.key));
     if (newVariables.length === 0) {
         return;
     }
@@ -56,13 +63,11 @@ async function appendToEnvFile(filePath, variables, fileType, options = {}) {
     content += "\n";
     content += `${ENV_MARKER_START} Added by StackKit\n`;
     for (const variable of newVariables) {
-        if (variable.description) {
-            content += `# ${variable.description}\n`;
-        }
-        const value = fileType === "example" ? variable.value || "" : variable.value || "";
+        const value = fileType === "example" ? (variable.value || "") : (variable.value || "");
         content += `${variable.key}=${value}\n`;
     }
     content += `${ENV_MARKER_END}\n`;
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
     await fs_extra_1.default.writeFile(filePath, content, "utf-8");
 }
 async function removeEnvVariables(projectRoot, keys) {
@@ -77,15 +82,35 @@ async function removeFromEnvFile(filePath, keys) {
     if (!(await fs_extra_1.default.pathExists(filePath))) {
         return;
     }
-    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
-    const lines = content.split("\n");
-    const newLines = [];
-    for (const line of lines) {
-        const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
-        if (match && keys.includes(match[1])) {
-            continue; // Skip this line
+    try {
+        const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+        const lines = content.split("\n");
+        const newLines = [];
+        let inStackKitBlock = false;
+        for (const line of lines) {
+            if (line.includes(ENV_MARKER_START)) {
+                inStackKitBlock = true;
+                continue;
+            }
+            if (line.includes(ENV_MARKER_END)) {
+                inStackKitBlock = false;
+                continue;
+            }
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+            if (match && keys.includes(match[1])) {
+                continue;
+            }
+            if (!inStackKitBlock || !line.startsWith("#")) {
+                newLines.push(line);
+            }
         }
-        newLines.push(line);
+        while (newLines.length > 0 && newLines[newLines.length - 1].trim() === "") {
+            newLines.pop();
+        }
+        await fs_extra_1.default.writeFile(filePath, newLines.join("\n"), "utf-8");
+    }
+    catch (error) {
+        logger_1.logger.error(`Failed to remove env variables from ${filePath}: ${error}`);
+        throw error;
     }
-    await fs_extra_1.default.writeFile(filePath, newLines.join("\n"), "utf-8");
 }

package/dist/utils/files.d.ts

@@ -1,3 +1,11 @@
+export interface PackageJsonConfig {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+}
+export declare function copyBaseFramework(templatesDir: string, targetDir: string, framework: string): Promise<void>;
+export declare function mergePackageJson(targetDir: string, config: PackageJsonConfig): Promise<void>;
+export declare function mergeEnvFile(targetDir: string, envVars: Record<string, string>): Promise<void>;
 export declare function copyTemplate(templatePath: string, targetPath: string, projectName: string): Promise<void>;
 export declare function createFile(targetPath: string, content: string, options?: {
     force?: boolean;

package/dist/utils/files.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyBaseFramework = copyBaseFramework;
+exports.mergePackageJson = mergePackageJson;
+exports.mergeEnvFile = mergeEnvFile;
 exports.copyTemplate = copyTemplate;
 exports.createFile = createFile;
 exports.readFile = readFile;
@@ -10,6 +13,54 @@ exports.fileExists = fileExists;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
+async function copyBaseFramework(templatesDir, targetDir, framework) {
+    const baseDir = path_1.default.join(templatesDir, framework);
+    if (!(await fs_extra_1.default.pathExists(baseDir))) {
+        throw new Error(`Base template not found for framework: ${framework}\n` + `Expected at: ${baseDir}`);
+    }
+    await fs_extra_1.default.copy(baseDir, targetDir, {
+        filter: (src) => {
+            const basename = path_1.default.basename(src);
+            return !["template.json", "config.json", "node_modules", ".git"].includes(basename);
+        },
+    });
+}
+async function mergePackageJson(targetDir, config) {
+    const pkgPath = path_1.default.join(targetDir, "package.json");
+    if (!(await fs_extra_1.default.pathExists(pkgPath))) {
+        return;
+    }
+    const pkg = await fs_extra_1.default.readJson(pkgPath);
+    if (config.dependencies) {
+        pkg.dependencies = { ...pkg.dependencies, ...config.dependencies };
+    }
+    if (config.devDependencies) {
+        pkg.devDependencies = { ...pkg.devDependencies, ...config.devDependencies };
+    }
+    if (config.scripts) {
+        pkg.scripts = { ...pkg.scripts, ...config.scripts };
+    }
+    await fs_extra_1.default.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+async function mergeEnvFile(targetDir, envVars) {
+    const envPath = path_1.default.join(targetDir, ".env");
+    let existingEnv = "";
+    if (await fs_extra_1.default.pathExists(envPath)) {
+        existingEnv = await fs_extra_1.default.readFile(envPath, "utf-8");
+    }
+    const envLines = existingEnv.split("\n").filter((line) => line.trim() !== "");
+    // Add new variables
+    for (const [key, value] of Object.entries(envVars)) {
+        const existingIndex = envLines.findIndex((line) => line.startsWith(`${key}=`));
+        if (existingIndex !== -1) {
+            envLines[existingIndex] = `${key}=${value}`;
+        }
+        else {
+            envLines.push(`${key}=${value}`);
+        }
+    }
+    await fs_extra_1.default.writeFile(envPath, envLines.join("\n") + "\n", "utf-8");
+}
 async function copyTemplate(templatePath, targetPath, projectName) {
     if (!(await fs_extra_1.default.pathExists(templatePath))) {
         throw new Error(`Template not found: ${templatePath}`);

package/dist/utils/js-conversion.d.ts

@@ -0,0 +1 @@
+export declare function convertToJavaScript(targetDir: string, framework: string): Promise<void>;

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>;