@reliverse/dler 1.7.92 → 1.7.94

package/bin/app/utils/agg/agg-1.js

@@ -0,0 +1,196 @@
+import path from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, inputPrompt, selectPrompt } from "@reliverse/rempts";
+import { getConfigDler } from "../../config/load.js";
+import { useAggregator } from "./agg-2.js";
+import { findMainEntryFile } from "./agg-4.js";
+import { isAggregationDisabled } from "./agg-5.js";
+export async function promptAggCommand() {
+  const config = await getConfigDler();
+  let selectedLibName = null;
+  const mainEntryFile = await findMainEntryFile(config);
+  const isMainDisabled = mainEntryFile ? await isAggregationDisabled(mainEntryFile) : false;
+  if (config?.libsList && Object.keys(config.libsList).length > 0) {
+    const libEntries = await Promise.all(
+      Object.entries(config.libsList).map(async ([name, lib]) => {
+        const libMainFile = `${config.libsDirSrc}/${lib.libMainFile}`;
+        const isLibDisabled = await isAggregationDisabled(libMainFile);
+        return {
+          name,
+          lib,
+          isDisabled: isLibDisabled
+        };
+      })
+    );
+    const libs = libEntries.filter(({ isDisabled }) => !isDisabled).map(({ name, lib }) => ({
+      value: name,
+      label: name,
+      hint: `${config.libsDirSrc}/${lib.libDirName}/${lib.libDirName}-impl`
+    }));
+    if (mainEntryFile && !isMainDisabled) {
+      libs.unshift({
+        value: "main",
+        label: "Main package",
+        hint: mainEntryFile
+      });
+    }
+    libs.push({ value: "", label: "Skip selection", hint: "" });
+    selectedLibName = await selectPrompt({
+      title: "Select a package to aggregate or skip",
+      options: libs
+    });
+  } else if (mainEntryFile && !isMainDisabled) {
+    const shouldUseMain = await confirmPrompt({
+      title: `Use main package for aggregation? (Found: ${mainEntryFile})`,
+      defaultValue: true
+    });
+    if (shouldUseMain) {
+      selectedLibName = "main";
+    }
+  }
+  let imports = false;
+  let input = "";
+  let named = true;
+  let out = "";
+  let recursive = true;
+  let strip = "";
+  let separateTypesFile = false;
+  let typesOut = "";
+  if (selectedLibName && selectedLibName !== "") {
+    if (selectedLibName === "main" && mainEntryFile && !isMainDisabled) {
+      const entryDir = path.dirname(mainEntryFile);
+      input = entryDir;
+      out = mainEntryFile;
+      strip = entryDir;
+    } else if (selectedLibName === "main" && isMainDisabled) {
+      relinka.verbose("Main package aggregation is disabled due to <dler-disable-agg> comment.");
+      return;
+    } else {
+      const libConfig = config?.libsList?.[selectedLibName];
+      if (config && libConfig) {
+        input = `${config.libsDirSrc}/${libConfig.libDirName}/${libConfig.libDirName}-impl`;
+        out = `${config.libsDirSrc}/${libConfig.libMainFile}`;
+        strip = `${config.libsDirSrc}/${libConfig.libDirName}`;
+      }
+    }
+  }
+  if (!selectedLibName || !input) {
+    input = await inputPrompt({
+      title: "Enter the input directory",
+      defaultValue: input
+    });
+    if (input) {
+      if (mainEntryFile && isMainDisabled) {
+        const mainEntryDir = path.dirname(mainEntryFile);
+        if (path.resolve(input) === path.resolve(mainEntryDir) || path.resolve(input) === path.resolve(mainEntryFile)) {
+          relinka.verbose(
+            "Main package aggregation is disabled due to <dler-disable-agg> comment."
+          );
+          return;
+        }
+      }
+      if (config?.libsList) {
+        for (const [libName, libConfig] of Object.entries(config.libsList)) {
+          const libImplPath = `${config.libsDirSrc}/${libConfig.libDirName}/${libConfig.libDirName}-impl`;
+          const libMainFile = `${config.libsDirSrc}/${libConfig.libMainFile}`;
+          if (path.resolve(input) === path.resolve(libImplPath) || path.resolve(input) === path.resolve(libMainFile)) {
+            const isLibDisabled = await isAggregationDisabled(libMainFile);
+            if (isLibDisabled) {
+              relinka.verbose(
+                `Library "${libName}" aggregation is disabled due to <dler-disable-agg> comment.`
+              );
+              return;
+            }
+          }
+        }
+      }
+    }
+  }
+  const verbose = await confirmPrompt({
+    title: "Enable verbose logging and additional options?",
+    defaultValue: false
+  });
+  let sortLines = false;
+  let headerComment = "";
+  let includeInternal = false;
+  let internalMarker = "#";
+  let overrideFile = false;
+  let extensions = ".ts,.js,.mts,.cts,.mjs,.cjs";
+  if (verbose) {
+    sortLines = await confirmPrompt({
+      title: "Sort aggregated lines alphabetically?",
+      defaultValue: false
+    });
+    headerComment = await inputPrompt({
+      title: "Add a header comment to the aggregator output (optional):",
+      defaultValue: ""
+    });
+    includeInternal = await confirmPrompt({
+      title: "Include files marked as internal (starting with #)?",
+      defaultValue: false
+    });
+    internalMarker = await inputPrompt({
+      title: "Marker for internal files:",
+      defaultValue: "#"
+    });
+    overrideFile = await confirmPrompt({
+      title: "Override entire file instead of updating only the aggregator block?",
+      defaultValue: false
+    });
+    extensions = await inputPrompt({
+      title: "File extensions to process (comma-separated):",
+      defaultValue: ".ts,.js,.mts,.cts,.mjs,.cjs"
+    });
+    imports = await confirmPrompt({
+      title: "Do you want to generate imports instead of exports? (N generates exports)",
+      defaultValue: imports
+    });
+    named = await confirmPrompt({
+      title: imports ? "Do you want to generate named imports?" : "Do you want to generate named exports?",
+      defaultValue: named
+    });
+    recursive = await confirmPrompt({
+      title: "Do you want to recursively scan subdirectories?",
+      defaultValue: recursive
+    });
+    separateTypesFile = await confirmPrompt({
+      title: "Do you want to create a separate file for type exports?",
+      defaultValue: separateTypesFile
+    });
+  }
+  if (!selectedLibName || !out) {
+    out = await inputPrompt({
+      title: "Enter the output file",
+      defaultValue: out
+    });
+  }
+  if (!selectedLibName || !strip) {
+    strip = await inputPrompt({
+      title: "Enter the path to strip from the final imports/exports",
+      defaultValue: strip
+    });
+  }
+  if (separateTypesFile) {
+    typesOut = await inputPrompt({
+      title: "Enter the output file for types",
+      defaultValue: out.replace(/\.(ts|js)$/, ".types.$1")
+    });
+  }
+  await useAggregator({
+    inputDir: path.resolve(input),
+    isRecursive: recursive,
+    outFile: path.resolve(out),
+    stripPrefix: strip ? path.resolve(strip) : "",
+    useImport: imports,
+    useNamed: named,
+    sortLines,
+    headerComment,
+    verbose,
+    includeInternal,
+    internalMarker,
+    overrideFile,
+    fileExtensions: extensions.split(",").map((ext) => ext.trim()),
+    separateTypesFile,
+    typesOutFile: typesOut ? path.resolve(typesOut) : void 0
+  });
+}

package/bin/app/utils/agg/agg-3.js

@@ -0,0 +1,197 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+export function buildPathRelative(filePath, inputDir, stripPrefix) {
+  let resolved = path.resolve(filePath);
+  const resolvedStrip = stripPrefix ? path.resolve(stripPrefix) : "";
+  if (resolvedStrip && resolved.startsWith(resolvedStrip)) {
+    resolved = resolved.slice(resolvedStrip.length);
+  } else {
+    resolved = path.relative(path.resolve(inputDir), resolved);
+  }
+  while (resolved.startsWith(path.sep)) {
+    resolved = resolved.slice(1);
+  }
+  resolved = resolved.replace(/\\/g, "/");
+  if (resolved.toLowerCase().endsWith(".ts")) {
+    resolved = `${resolved.slice(0, -3)}.js`;
+  }
+  if (!resolved.startsWith("./") && !resolved.startsWith("../")) {
+    resolved = `./${resolved}`;
+  }
+  resolved = resolved.replace(/\/+/g, "/");
+  return resolved;
+}
+export async function collectFiles(dir, exts, recursive, ignoreDirs, verbose, includeInternal, internalMarker, outFile) {
+  const found = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (outFile && path.resolve(fullPath) === path.resolve(outFile)) {
+      if (verbose) {
+        relinka("verbose", `Skipping output file: ${fullPath}`);
+      }
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (ignoreDirs.includes(entry.name)) {
+        if (verbose) {
+          relinka("verbose", `Skipping ignored directory: ${fullPath}`);
+        }
+        continue;
+      }
+      if (recursive) {
+        const sub = await collectFiles(
+          fullPath,
+          exts,
+          recursive,
+          ignoreDirs,
+          verbose,
+          includeInternal,
+          internalMarker,
+          outFile
+        );
+        found.push(...sub);
+      }
+    } else if (entry.isFile()) {
+      if (!includeInternal && path.basename(fullPath).startsWith(internalMarker)) {
+        if (verbose) {
+          relinka("verbose", `Skipping internal file: ${fullPath}`);
+        }
+        continue;
+      }
+      if (exts.some((ext) => entry.name.toLowerCase().endsWith(ext))) {
+        if (verbose) {
+          relinka("verbose", `Found file: ${fullPath}`);
+        }
+        found.push(fullPath);
+      }
+    }
+  }
+  return found;
+}
+export async function generateAggregatorLines(filePath, inputDir, stripPrefix, useImport, useNamed, usedIdentifiers) {
+  const importPath = buildPathRelative(filePath, inputDir, stripPrefix);
+  if (!useNamed) {
+    if (useImport) {
+      let ident = guessStarImportIdentifier(filePath);
+      if (usedIdentifiers) {
+        let uniqueIdent = ident;
+        let counter = 1;
+        while (usedIdentifiers.has(uniqueIdent)) {
+          uniqueIdent = `${ident}_${counter}`;
+          counter++;
+        }
+        usedIdentifiers.add(uniqueIdent);
+        ident = uniqueIdent;
+      }
+      return [`import * as ${ident} from "${importPath}";`];
+    }
+    return [`export * from "${importPath}";`];
+  }
+  const { typeNames, valueNames } = await getNamedExports(filePath);
+  if (!typeNames.length && !valueNames.length) {
+    return [];
+  }
+  if (useImport) {
+    const lines2 = [];
+    if (typeNames.length > 0) {
+      lines2.push(`import type { ${typeNames.join(", ")} } from "${importPath}";`);
+    }
+    if (valueNames.length > 0) {
+      lines2.push(`import { ${valueNames.join(", ")} } from "${importPath}";`);
+    }
+    return lines2;
+  }
+  const lines = [];
+  if (typeNames.length > 0) {
+    lines.push(`export type { ${typeNames.join(", ")} } from "${importPath}";`);
+  }
+  if (valueNames.length > 0) {
+    lines.push(`export { ${valueNames.join(", ")} } from "${importPath}";`);
+  }
+  return lines;
+}
+export async function getNamedExports(filePath) {
+  try {
+    const code = await fs.readFile(filePath, "utf8");
+    const typeNamesSet = /* @__PURE__ */ new Set();
+    const valueNamesSet = /* @__PURE__ */ new Set();
+    const patterns = [
+      // Regular exports and default exports
+      /^export\s+(?:default\s+)?(?:async\s+)?(function|const|class|let|var|type|interface|enum)\s+([A-Za-z0-9_$]+)/gm,
+      // Named exports and re-exports
+      /^export\s*{([^}]+)}(?:\s+from\s+['"][^'"]+['"])?/gm,
+      // Export assignments
+      /^export\s*=\s*([A-Za-z0-9_$]+)/gm
+    ];
+    for (const pattern of patterns) {
+      let match;
+      while (true) {
+        match = pattern.exec(code);
+        if (!match) break;
+        const matchGroups = match;
+        if (pattern.source.includes("{([^}]+)}") && matchGroups[1]) {
+          const exports = (matchGroups[1] ?? "").split(",").map(
+            (e) => e?.trim()?.split(/\s+as\s+/)?.[0]?.trim() ?? ""
+          );
+          for (const exp of exports) {
+            const name = exp.replace(/^type\s+/, "");
+            if (exp.startsWith("type ")) {
+              typeNamesSet.add(name);
+            } else {
+              valueNamesSet.add(name);
+            }
+          }
+        } else if (pattern.source.includes("=\\s*([A-Za-z0-9_$]+)") && matchGroups[1]) {
+          valueNamesSet.add(matchGroups[1]);
+        } else {
+          const keyword = matchGroups[1];
+          const name = matchGroups[2];
+          if (keyword && name) {
+            if (keyword === "type" || keyword === "interface" || keyword === "enum") {
+              typeNamesSet.add(name);
+            } else {
+              valueNamesSet.add(name);
+            }
+          }
+        }
+      }
+    }
+    return {
+      typeNames: Array.from(typeNamesSet),
+      valueNames: Array.from(valueNamesSet)
+    };
+  } catch (error) {
+    relinka("error", `Error reading file ${filePath}: ${error}`);
+    return { typeNames: [], valueNames: [] };
+  }
+}
+export function guessStarImportIdentifier(filePath) {
+  const base = path.basename(filePath, path.extname(filePath));
+  let identifier = base.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(identifier)) {
+    identifier = `_${identifier}`;
+  }
+  return identifier || "file";
+}
+export function printUsage(isDev) {
+  relinka("verbose", "====================");
+  relinka("verbose", "TOOLS USAGE EXAMPLES");
+  relinka("verbose", "====================");
+  relinka(
+    "log",
+    `${isDev ? "bun dev:agg" : "dler tools"} --tool agg --input <dir> --out <file> [options]`
+  );
+  if (isDev) {
+    relinka(
+      "log",
+      "bun dev:tools agg --input src-ts/app --out src-ts/mod.ts --recursive --named --strip src-ts/app"
+    );
+  } else {
+    relinka(
+      "log",
+      "dler tools --tool agg --input src-ts/libs --out aggregator.ts --recursive --named"
+    );
+  }
+}

package/bin/app/utils/agg/agg-5.js

@@ -0,0 +1,10 @@
+import fs from "@reliverse/relifso";
+export async function isAggregationDisabled(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const firstLine = content.split("\n")[0]?.trim();
+    return firstLine === "// <dler-disable-agg>";
+  } catch {
+    return false;
+  }
+}

package/bin/app/utils/badgeNotifiers.d.ts

@@ -0,0 +1,2 @@
+export declare const recommended: any;
+export declare const experimental: any;

package/bin/app/utils/badgeNotifiers.js

@@ -0,0 +1,3 @@
+import { re } from "@reliverse/relico";
+export const recommended = re.green("\u{1F680} Recommended");
+export const experimental = re.red("\u{1F6A8} Experimental");

package/bin/app/utils/codemods/convertCjsToEsm.d.ts

@@ -0,0 +1 @@
+export declare function convertCjsToEsm(projectPath: string): Promise<void>;

package/bin/app/utils/codemods/convertCjsToEsm.js

@@ -0,0 +1,27 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { glob } from "tinyglobby";
+export async function convertCjsToEsm(projectPath) {
+  relinka("info", `Converting CommonJS to ESM in ${projectPath}`);
+  const files = await glob("**/*.{js,jsx,ts,tsx}", {
+    cwd: path.resolve(projectPath)
+  });
+  for (const file of files) {
+    const filePath = path.join(projectPath, file);
+    const content = await fs.readFile(filePath, "utf-8");
+    let updatedContent = content;
+    updatedContent = updatedContent.replace(
+      /(?:const|let|var)\s*{\s*([^}]+)}\s*=\s*require\(['"]([^'"]+)['"]\)/g,
+      'import { $1 } from "$2"'
+    ).replace(
+      /(?:const|let|var)\s+(\w+)\s*=\s*require\(['"]([^'"]+)['"]\)/g,
+      'import $1 from "$2"'
+    );
+    updatedContent = updatedContent.replace(/module\.exports\s*=\s*([^;\n]+)/g, "export default $1").replace(/module\.exports\.(\w+)\s*=\s*([^;\n]+)/g, "export const $1 = $2").replace(/exports\.(\w+)\s*=\s*([^;\n]+)/g, "export const $1 = $2");
+    if (content !== updatedContent) {
+      await fs.writeFile(filePath, updatedContent, "utf-8");
+      relinka("info", `Converted ${filePath} to ESM`);
+    }
+  }
+}

package/bin/app/utils/codemods/convertDatabase.d.ts

@@ -0,0 +1,2 @@
+export declare function convertPrismaToDrizzle(cwd: string, targetDbType: string): Promise<void>;
+export declare function convertDatabaseProvider(cwd: string, fromProvider: string, toProvider: string): Promise<void>;

package/bin/app/utils/codemods/convertDatabase.js

@@ -0,0 +1,229 @@
+import path from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON, writePackageJSON } from "pkg-types";
+function parsePrismaSchema(content) {
+  const models = [];
+  const modelRegex = /model\s+(\w+)\s*{([^}]+)}/g;
+  const fieldRegex = /(\w+)\s+(\w+)(\[\])?\s*(\?)?\s*(@[^@\n]+)?/g;
+  let match;
+  while ((match = modelRegex.exec(content)) !== null) {
+    const [_, modelName, fieldsStr] = match;
+    const fields = [];
+    let fieldMatch;
+    if (fieldsStr) {
+      while ((fieldMatch = fieldRegex.exec(fieldsStr)) !== null) {
+        const [_2, name, type, isList, isOptional, attributes] = fieldMatch;
+        if (name && type) {
+          fields.push({
+            name,
+            type,
+            isOptional: !!isOptional,
+            isList: !!isList,
+            attributes: parseAttributes(attributes ?? "")
+          });
+        }
+      }
+    }
+    if (modelName) {
+      models.push({ name: modelName, fields });
+    }
+  }
+  return models;
+}
+function parseAttributes(attributesStr) {
+  const attributes = {};
+  const attrRegex = /@(\w+)(?:\((.*?)\))?/g;
+  let match;
+  while ((match = attrRegex.exec(attributesStr)) !== null) {
+    const [_, name, args] = match;
+    if (name) {
+      attributes[name] = args ? parseAttributeArgs(args) : true;
+    }
+  }
+  return attributes;
+}
+function parseAttributeArgs(args) {
+  if (args.startsWith("[") && args.endsWith("]")) {
+    return args.slice(1, -1).split(",").map((s) => s.trim());
+  }
+  if (args === "true") {
+    return true;
+  }
+  if (args === "false") {
+    return false;
+  }
+  if (/^\d+$/.test(args)) {
+    return parseInt(args, 10);
+  }
+  return args.replace(/['"]/g, "");
+}
+function convertPrismaToDrizzleType(field, dbType) {
+  const typeMap = {
+    postgres: {
+      Int: "integer",
+      String: "text",
+      Boolean: "boolean",
+      DateTime: "timestamp",
+      Float: "real",
+      BigInt: "bigint",
+      Decimal: "decimal",
+      Json: "jsonb",
+      Bytes: "bytea"
+    },
+    mysql: {
+      Int: "int",
+      String: "text",
+      Boolean: "boolean",
+      DateTime: "timestamp",
+      Float: "float",
+      BigInt: "bigint",
+      Decimal: "decimal",
+      Json: "json",
+      Bytes: "blob"
+    },
+    sqlite: {
+      Int: "integer",
+      String: "text",
+      Boolean: "integer",
+      DateTime: "integer",
+      Float: "real",
+      BigInt: "integer",
+      Decimal: "real",
+      Json: "text",
+      Bytes: "blob"
+    }
+  };
+  return typeMap[dbType]?.[field.type] ?? "text";
+}
+function generateDrizzleSchema(models, dbType) {
+  const tablePrefix = dbType === "postgres" ? "pg" : dbType === "mysql" ? "mysql" : "sqlite";
+  const imports = /* @__PURE__ */ new Set([`${tablePrefix}Table`]);
+  const modelSchemas = models.map((model) => {
+    const fields = model.fields.map((field) => {
+      const drizzleType = convertPrismaToDrizzleType(field, dbType);
+      imports.add(drizzleType);
+      let fieldDef = `${field.name}: ${drizzleType}("${field.name}")`;
+      if (field.attributes.id) {
+        fieldDef += ".primaryKey()";
+      }
+      if (field.attributes.unique) {
+        fieldDef += ".unique()";
+      }
+      if (!field.isOptional) {
+        fieldDef += ".notNull()";
+      }
+      if (field.attributes.default) {
+        if (field.type === "DateTime" && field.attributes.default === "now()") {
+          fieldDef += ".default(sql`CURRENT_TIMESTAMP`)";
+          imports.add("sql");
+        } else {
+          fieldDef += `.default(${field.attributes.default})`;
+        }
+      }
+      return fieldDef;
+    });
+    return `export const ${model.name.toLowerCase()} = ${tablePrefix}Table("${model.name.toLowerCase()}", {
+  ${fields.join(",\n  ")}
+});`;
+  });
+  let importStatement = `import { ${Array.from(imports).join(", ")} } from "drizzle-orm/${dbType}";`;
+  if (imports.has("sql")) {
+    importStatement = `import { sql } from "drizzle-orm";
+${importStatement}`;
+  }
+  return `${importStatement}
+${modelSchemas.join("\n\n")}`;
+}
+export async function convertPrismaToDrizzle(cwd, targetDbType) {
+  const prismaSchemaPath = path.join(cwd, "prisma/schema.prisma");
+  if (!await fs.pathExists(prismaSchemaPath)) {
+    relinka("error", "No Prisma schema found");
+    return;
+  }
+  const schemaContent = await fs.readFile(prismaSchemaPath, "utf-8");
+  const models = parsePrismaSchema(schemaContent);
+  const drizzleSchema = generateDrizzleSchema(models, targetDbType);
+  const drizzleConfig = `import type { Config } from "drizzle-kit";
+export default {
+  schema: "./src/db/schema.ts",
+  out: "./drizzle",
+} satisfies Config;`;
+  await ensuredir(path.join(cwd, "src/db"));
+  await fs.writeFile(path.join(cwd, "src/db/schema.ts"), drizzleSchema);
+  await fs.writeFile(path.join(cwd, "drizzle.config.ts"), drizzleConfig);
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (packageJson.dependencies) {
+      packageJson.dependencies["@prisma/client"] = "";
+    }
+    if (packageJson.devDependencies) {
+      packageJson.devDependencies.prisma = "";
+    }
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "drizzle-orm": "latest"
+    };
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      "drizzle-kit": "latest"
+    };
+    if (targetDbType === "postgres") {
+      packageJson.dependencies.postgres = "latest";
+    } else if (targetDbType === "mysql") {
+      packageJson.dependencies.mysql2 = "latest";
+    } else if (targetDbType === "sqlite") {
+      packageJson.dependencies["better-sqlite3"] = "latest";
+      packageJson.devDependencies["@types/better-sqlite3"] = "latest";
+    }
+    await writePackageJSON(packageJsonPath, packageJson);
+  }
+  relinka("success", "Converted Prisma schema to Drizzle schema");
+}
+export async function convertDatabaseProvider(cwd, fromProvider, toProvider) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!await fs.pathExists(packageJsonPath)) {
+    relinka("error", "No package.json found");
+    return;
+  }
+  const packageJson = await readPackageJSON(packageJsonPath);
+  if (fromProvider === "postgres" && toProvider === "libsql") {
+    if (packageJson.dependencies) {
+      packageJson.dependencies.postgres = "";
+      packageJson.dependencies["@neondatabase/serverless"] = "";
+    }
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@libsql/client": "latest"
+    };
+    const envPath = path.join(cwd, ".env");
+    if (await fs.pathExists(envPath)) {
+      let envContent = await fs.readFile(envPath, "utf-8");
+      envContent = envContent.replace(
+        /DATABASE_URL=.*postgres:\/\/.*/g,
+        "DATABASE_URL=libsql://[YOUR-DATABASE].turso.io"
+      );
+      await fs.writeFile(envPath, envContent);
+    }
+    const dbClientPaths = ["src/lib/db.ts", "src/db/client.ts", "src/database/index.ts"];
+    for (const memoryPath of dbClientPaths) {
+      const fullPath = path.join(cwd, memoryPath);
+      if (await fs.pathExists(fullPath)) {
+        let content = await fs.readFile(fullPath, "utf-8");
+        content = content.replace(
+          /import .*postgres.*/g,
+          'import { createClient } from "@libsql/client";'
+        );
+        content = content.replace(
+          /const .*= new Pool\(.*\)/g,
+          "const client = createClient({ url: process.env.DATABASE_URL! });"
+        );
+        await fs.writeFile(fullPath, content);
+        break;
+      }
+    }
+  }
+  await writePackageJSON(packageJsonPath, packageJson);
+  relinka("success", `Converted database provider from ${fromProvider} to ${toProvider}`);
+}

package/bin/app/utils/codemods/convertDefinitions.d.ts

@@ -0,0 +1 @@
+export declare function convertTypeDefinitions(projectPath: string, targetStyle: "type" | "interface"): Promise<void>;