@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/init/mm-deprecated/drizzle/manageDrizzleSchemaUtils.js

@@ -0,0 +1,474 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, inputPrompt, selectPrompt } from "@reliverse/rempts";
+import { installIntegration } from "../editor-mod.js";
+import { INTEGRATION_CONFIGS } from "../feature-add.js";
+import { COLUMN_TYPES } from "./manageDrizzleConstants.js";
+export async function detectDatabaseProvider(cwd) {
+  const drizzleConfigPath = path.join(cwd, "drizzle.config.ts");
+  if (await fs.pathExists(drizzleConfigPath)) {
+    const content = await fs.readFile(drizzleConfigPath, "utf-8");
+    if (content.includes("postgres")) {
+      return "postgres";
+    }
+    if (content.includes("sqlite")) {
+      return "sqlite";
+    }
+    if (content.includes("mysql")) {
+      return "mysql";
+    }
+  }
+  return null;
+}
+export async function setupDrizzle(cwd, isDev) {
+  relinka("info", "Drizzle is not set up in this project. Let's set it up first.");
+  const provider = await selectPrompt({
+    title: "Select database provider:",
+    options: [
+      { label: "PostgreSQL", value: "postgres" },
+      { label: "SQLite", value: "sqlite" },
+      { label: "MySQL", value: "mysql" }
+    ]
+  });
+  if (provider === "postgres") {
+    const pgProvider = await selectPrompt({
+      title: "Select PostgreSQL provider:",
+      options: [
+        { label: "Neon", value: "neon" },
+        { label: "Railway", value: "railway" },
+        { label: "Other", value: "postgres" }
+      ]
+    });
+    const drizzleConfig = INTEGRATION_CONFIGS.drizzle;
+    if (!drizzleConfig) {
+      throw new Error("Drizzle integration configuration not found");
+    }
+    const config = {
+      ...drizzleConfig,
+      dependencies: [
+        ...drizzleConfig.dependencies,
+        pgProvider === "neon" ? "@neondatabase/serverless" : "postgres"
+      ]
+    };
+    await installIntegration(cwd, config, isDev);
+  } else {
+    const drizzleConfig = INTEGRATION_CONFIGS.drizzle;
+    if (!drizzleConfig) {
+      throw new Error("Drizzle integration configuration not found");
+    }
+    await installIntegration(cwd, drizzleConfig, isDev);
+  }
+  return provider;
+}
+export async function getAvailableTables(cwd, useMultipleFiles) {
+  if (useMultipleFiles) {
+    const schemaDir = path.join(cwd, "src/db/schema");
+    const files = await fs.readdir(schemaDir);
+    return files.filter((file) => file.endsWith(".ts") && file !== "index.ts").map((file) => file.replace(".ts", ""));
+  } else {
+    const schemaFile = path.join(cwd, "src/db/schema.ts");
+    if (await fs.pathExists(schemaFile)) {
+      const content = await fs.readFile(schemaFile, "utf-8");
+      const tableMatches = content.match(/export const (\w+)\s*=/g);
+      return tableMatches ? tableMatches.map((match) => match.split(" ")[2]).filter((name) => name !== void 0) : [];
+    }
+  }
+  return [];
+}
+export async function addNewTable(cwd, useMultipleFiles, provider) {
+  const tableName = await inputPrompt({
+    title: "Enter the table name:",
+    validate: (value) => {
+      if (!value?.trim()) {
+        return "Table name is required";
+      }
+      if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)) {
+        return "Table name must start with a letter and contain only letters, numbers, and underscores";
+      }
+      return true;
+    }
+  });
+  const columns = [];
+  let addingColumns = true;
+  while (addingColumns) {
+    const columnName = await inputPrompt({
+      title: "Enter column name:",
+      validate: (value) => {
+        if (!value?.trim()) {
+          return "Column name is required";
+        }
+        if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)) {
+          return "Column name must start with a letter and contain only letters, numbers, and underscores";
+        }
+        return true;
+      }
+    });
+    const columnType = await selectPrompt({
+      title: "Select column type:",
+      options: COLUMN_TYPES[provider].map((type) => ({
+        label: type,
+        value: type
+      }))
+    });
+    const nullable = await confirmPrompt({
+      title: "Is this column nullable?",
+      defaultValue: false
+    });
+    const primaryKey = await confirmPrompt({
+      title: "Is this column a primary key?",
+      defaultValue: false
+    });
+    const unique = !primaryKey && await confirmPrompt({
+      title: "Should this column be unique?",
+      defaultValue: false
+    });
+    const hasDefaultValue = await confirmPrompt({
+      title: "Do you want to set a default value?",
+      defaultValue: false
+    });
+    let defaultValue;
+    if (hasDefaultValue) {
+      if (columnType === "timestamp" || columnType === "timestamptz" || columnType === "datetime") {
+        const useNow = await confirmPrompt({
+          title: "Use current timestamp as default?",
+          defaultValue: true
+        });
+        if (useNow) {
+          defaultValue = "sql`CURRENT_TIMESTAMP`";
+        }
+      } else {
+        defaultValue = await inputPrompt({
+          title: "Enter default value:"
+        });
+      }
+    }
+    const isReference = await confirmPrompt({
+      title: "Is this a foreign key reference?",
+      defaultValue: false
+    });
+    let references;
+    if (isReference) {
+      const tables = await getAvailableTables(
+        cwd,
+        useMultipleFiles
+        // singleSchemaDir,
+        // multiSchemaDir,
+      );
+      if (tables.length > 0) {
+        const refTable = await selectPrompt({
+          title: "Select referenced table:",
+          options: tables.map((t) => ({ label: t, value: t }))
+        });
+        references = {
+          table: refTable,
+          column: "id"
+          // Assuming referenced column is always 'id' for simplicity
+        };
+      }
+    }
+    columns.push({
+      name: columnName,
+      type: columnType,
+      nullable,
+      primaryKey,
+      unique,
+      ...defaultValue && { defaultValue },
+      ...references && { references }
+    });
+    addingColumns = await confirmPrompt({
+      title: "Add another column?",
+      defaultValue: true
+    });
+  }
+  const schema = {
+    name: tableName,
+    columns
+  };
+  if (useMultipleFiles) {
+    const filePath = path.join(cwd, "src/db/schema", `${tableName}.ts`);
+    await generateTableFile(filePath, schema, provider);
+    const indexPath = path.join(cwd, "src/db/schema/index.ts");
+    await updateSchemaIndex(indexPath, tableName);
+  } else {
+    const filePath = path.join(cwd, "src/db/schema.ts");
+    await appendTableToSchema(filePath, schema, provider);
+  }
+  relinka("success", `Table ${tableName} created successfully!`);
+}
+export async function removeTable(cwd, useMultipleFiles, provider) {
+  const tables = await getAvailableTables(cwd, useMultipleFiles);
+  if (tables.length === 0) {
+    relinka("error", "No tables found to remove");
+    return;
+  }
+  const tableName = await selectPrompt({
+    title: "Select table to remove:",
+    options: tables.map((t) => ({ label: t, value: t }))
+  });
+  const confirm = await confirmPrompt({
+    title: `Are you sure you want to remove the table ${tableName}?`,
+    content: "This action cannot be undone",
+    defaultValue: false
+  });
+  if (!confirm) {
+    relinka("info", "Table removal cancelled");
+    return;
+  }
+  if (useMultipleFiles) {
+    const filePath = path.join(cwd, "src/db/schema", `${tableName}.ts`);
+    await fs.remove(filePath);
+    const indexPath = path.join(cwd, "src/db/schema/index.ts");
+    await removeFromSchemaIndex(indexPath, tableName);
+  } else {
+    const filePath = path.join(cwd, "src/db/schema.ts");
+    await removeTableFromSchema(filePath, tableName, provider);
+  }
+  relinka("success", `Table ${tableName} removed successfully!`);
+}
+export async function renameTable(cwd, useMultipleFiles, provider) {
+  const tables = await getAvailableTables(cwd, useMultipleFiles);
+  if (tables.length === 0) {
+    relinka("error", "No tables found to rename");
+    return;
+  }
+  const oldName = await selectPrompt({
+    title: "Select table to rename:",
+    options: tables.map((t) => ({ label: t, value: t }))
+  });
+  const newName = await inputPrompt({
+    title: "Enter new table name:",
+    validate: (value) => {
+      if (!value?.trim()) {
+        return "Table name is required";
+      }
+      if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(value)) {
+        return "Table name must start with a letter and contain only letters, numbers, and underscores";
+      }
+      if (tables.includes(value)) {
+        return "A table with this name already exists";
+      }
+      return true;
+    }
+  });
+  if (useMultipleFiles) {
+    const oldPath = path.join(cwd, "src/db/schema", `${oldName}.ts`);
+    const newPath = path.join(cwd, "src/db/schema", `${newName}.ts`);
+    await fs.move(oldPath, newPath);
+    const indexPath = path.join(cwd, "src/db/schema/index.ts");
+    await updateTableNameInIndex(indexPath, oldName, newName);
+  } else {
+    const filePath = path.join(cwd, "src/db/schema.ts");
+    await renameTableInSchema(filePath, oldName, newName, provider);
+  }
+  relinka("success", `Table renamed from ${oldName} to ${newName} successfully!`);
+}
+export async function manageRelations(cwd, useMultipleFiles, provider) {
+  const tables = await getAvailableTables(cwd, useMultipleFiles);
+  if (tables.length < 2) {
+    relinka("error", "Need at least two tables to manage relations");
+    return;
+  }
+  const sourceTable = await selectPrompt({
+    title: "Select source table:",
+    options: tables.map((t) => ({ label: t, value: t }))
+  });
+  const targetTable = await selectPrompt({
+    title: "Select target table:",
+    options: tables.filter((t) => t !== sourceTable).map((t) => ({ label: t, value: t }))
+  });
+  const relationType = await selectPrompt({
+    title: "Select relation type:",
+    options: [
+      { label: "One-to-One", value: "oneToOne" },
+      { label: "One-to-Many", value: "oneToMany" },
+      { label: "Many-to-Many", value: "manyToMany" }
+    ]
+  });
+  if (relationType === "manyToMany") {
+    const junctionTableName = `${sourceTable}_to_${targetTable}`;
+    const schema = {
+      name: junctionTableName,
+      columns: [
+        {
+          name: `${sourceTable}Id`,
+          type: "integer",
+          nullable: false,
+          references: { table: sourceTable, column: "id" }
+        },
+        {
+          name: `${targetTable}Id`,
+          type: "integer",
+          nullable: false,
+          references: { table: targetTable, column: "id" }
+        }
+      ]
+    };
+    if (useMultipleFiles) {
+      const filePath = path.join(cwd, "src/db/schema", `${junctionTableName}.ts`);
+      await generateTableFile(filePath, schema, provider);
+      const indexPath = path.join(cwd, "src/db/schema/index.ts");
+      await updateSchemaIndex(indexPath, junctionTableName);
+    } else {
+      const filePath = path.join(cwd, "src/db/schema.ts");
+      await appendTableToSchema(filePath, schema, provider);
+    }
+  } else {
+    const column = {
+      name: `${targetTable}Id`,
+      type: "integer",
+      nullable: relationType === "oneToMany",
+      references: { table: targetTable, column: "id" }
+    };
+    if (useMultipleFiles) {
+      const filePath = path.join(cwd, "src/db/schema", `${sourceTable}.ts`);
+      await addColumnToTable(filePath, sourceTable, column, provider);
+    } else {
+      const filePath = path.join(cwd, "src/db/schema.ts");
+      await addColumnToTable(filePath, sourceTable, column, provider);
+    }
+  }
+  relinka("success", "Relation added successfully!");
+}
+export async function generateTableFile(filePath, schema, provider) {
+  const dbPrefix = provider === "postgres" ? "pg" : provider;
+  const content = `import { sql } from "drizzle-orm";
+  import { ${schema.columns.map((c) => c.type).join(", ")}, ${dbPrefix}Table } from "drizzle-orm/${provider}-core";
+  export const ${schema.name} = ${dbPrefix}Table("${schema.name}", {
+    ${schema.columns.map((col) => {
+    let def = `${col.name}: ${col.type}("${col.name}")`;
+    if (col.primaryKey) {
+      def += ".primaryKey()";
+    }
+    if (col.unique) {
+      def += ".unique()";
+    }
+    if (!col.nullable) {
+      def += ".notNull()";
+    }
+    if (col.defaultValue) {
+      def += `.default(${col.defaultValue})`;
+    }
+    if (col.references) {
+      def += `.references(() => ${col.references.table}.${col.references.column})`;
+    }
+    return def;
+  }).join(",\n  ")}
+  });`;
+  await fs.writeFile(filePath, content);
+}
+export async function updateSchemaIndex(indexPath, tableName) {
+  let content = "";
+  if (await fs.pathExists(indexPath)) {
+    content = await fs.readFile(indexPath, "utf-8");
+  }
+  const exportStatement = `export * from "./${tableName}";`;
+  if (!content.includes(exportStatement)) {
+    content += content ? `
+${exportStatement}` : exportStatement;
+    await fs.writeFile(indexPath, content);
+  }
+}
+export async function appendTableToSchema(filePath, schema, provider) {
+  let content = "";
+  if (await fs.pathExists(filePath)) {
+    content = await fs.readFile(filePath, "utf-8");
+  }
+  const dbPrefix = provider === "postgres" ? "pg" : provider;
+  const tableDefinition = `
+export const ${schema.name} = ${dbPrefix}Table("${schema.name}", {
+    ${schema.columns.map((col) => {
+    let def = `${col.name}: ${col.type}("${col.name}")`;
+    if (col.primaryKey) {
+      def += ".primaryKey()";
+    }
+    if (col.unique) {
+      def += ".unique()";
+    }
+    if (!col.nullable) {
+      def += ".notNull()";
+    }
+    if (col.defaultValue) {
+      def += `.default(${col.defaultValue})`;
+    }
+    if (col.references) {
+      def += `.references(() => ${col.references.table}.${col.references.column})`;
+    }
+    return def;
+  }).join(",\n  ")}
+  });`;
+  content += tableDefinition;
+  await fs.writeFile(filePath, content);
+}
+export async function removeFromSchemaIndex(indexPath, tableName) {
+  if (await fs.pathExists(indexPath)) {
+    let content = await fs.readFile(indexPath, "utf-8");
+    content = content.replace(`export * from "./${tableName}";`, "");
+    content = content.replace(/\n\n+/g, "\n");
+    await fs.writeFile(indexPath, content);
+  }
+}
+export async function removeTableFromSchema(filePath, tableName, provider) {
+  if (await fs.pathExists(filePath)) {
+    let content = await fs.readFile(filePath, "utf-8");
+    const dbPrefix = provider === "postgres" ? "pg" : provider;
+    const regex = new RegExp(
+      `\\nexport const ${tableName} = ${dbPrefix}Table[\\s\\S]*?\\);\\n?`,
+      "g"
+    );
+    content = content.replace(regex, "\n");
+    content = content.replace(/\n\n+/g, "\n\n");
+    await fs.writeFile(filePath, content);
+  }
+}
+export async function renameTableInSchema(filePath, oldName, newName, provider) {
+  if (await fs.pathExists(filePath)) {
+    let content = await fs.readFile(filePath, "utf-8");
+    const dbPrefix = provider === "postgres" ? "pg" : provider;
+    content = content.replace(
+      new RegExp(`export const ${oldName} = ${dbPrefix}Table\\("${oldName}"`, "g"),
+      `export const ${newName} = ${dbPrefix}Table("${newName}"`
+    );
+    await fs.writeFile(filePath, content);
+  }
+}
+export async function updateTableNameInIndex(indexPath, oldName, newName) {
+  if (await fs.pathExists(indexPath)) {
+    let content = await fs.readFile(indexPath, "utf-8");
+    content = content.replace(`export * from "./${oldName}";`, `export * from "./${newName}";`);
+    await fs.writeFile(indexPath, content);
+  }
+}
+export async function addColumnToTable(filePath, tableName, column, provider) {
+  if (await fs.pathExists(filePath)) {
+    let content = await fs.readFile(filePath, "utf-8");
+    const dbPrefix = provider === "postgres" ? "pg" : provider;
+    const tableRegex = new RegExp(`export const ${tableName} = ${dbPrefix}Table\\([\\s\\S]*?\\);`);
+    const match = content.match(tableRegex);
+    if (match) {
+      const tableContent = match[0];
+      const insertPoint = tableContent.lastIndexOf("}");
+      let columnDef = `
+  ${column.name}: ${column.type}("${column.name}")`;
+      if (column.primaryKey) {
+        columnDef += ".primaryKey()";
+      }
+      if (column.unique) {
+        columnDef += ".unique()";
+      }
+      if (!column.nullable) {
+        columnDef += ".notNull()";
+      }
+      if (column.defaultValue) {
+        columnDef += `.default(${column.defaultValue})`;
+      }
+      if (column.references) {
+        columnDef += `.references(() => ${column.references.table}.${column.references.column})`;
+      }
+      columnDef += ",";
+      const newTableContent = tableContent.slice(0, insertPoint) + columnDef + tableContent.slice(insertPoint);
+      content = content.replace(tableRegex, newTableContent);
+      await fs.writeFile(filePath, content);
+    }
+  }
+}

package/bin/app/init/mm-deprecated/editor-impl.d.ts

@@ -0,0 +1 @@
+export declare function handleIntegrations(cwd: string, isDev: boolean): Promise<void>;

package/bin/app/init/mm-deprecated/editor-impl.js

@@ -0,0 +1,153 @@
+import { relinka } from "@reliverse/relinka";
+import { confirmPrompt, selectPrompt } from "@reliverse/rempts";
+import { installIntegration, removeIntegration } from "./editor-mod.js";
+import { INTEGRATION_CONFIGS } from "./feature-add.js";
+import { REMOVAL_CONFIGS } from "./feature-rm.js";
+export async function handleIntegrations(cwd, isDev) {
+  const integrationOptions = {
+    database: [
+      {
+        label: "Drizzle",
+        value: "drizzle",
+        subOptions: [
+          {
+            label: "PostgreSQL",
+            value: "postgres",
+            providers: ["neon", "railway"]
+          },
+          { label: "SQLite", value: "sqlite" },
+          { label: "MySQL", value: "mysql" }
+        ]
+      },
+      { label: "Prisma", value: "prisma" },
+      { label: "Supabase", value: "supabase" },
+      { label: "None (Remove existing)", value: "none" }
+    ],
+    payments: [
+      { label: "Stripe", value: "stripe" },
+      { label: "Polar", value: "polar" },
+      { label: "None (Remove existing)", value: "none" }
+    ],
+    auth: [
+      { label: "NextAuth.js", value: "next-auth" },
+      { label: "Clerk", value: "clerk" },
+      { label: "Better-Auth", value: "better-auth" },
+      { label: "None (Remove existing)", value: "none" }
+    ],
+    email: [
+      { label: "Resend", value: "resend" },
+      { label: "None (Remove existing)", value: "none" }
+    ],
+    styling: [
+      { label: "Tailwind CSS", value: "tailwind" },
+      { label: "shadcn/ui", value: "shadcn" },
+      { label: "None (Remove existing)", value: "none" }
+    ],
+    testing: [
+      { label: "Bun Test", value: "bun-test" },
+      { label: "Vitest", value: "vitest" },
+      { label: "Jest", value: "jest" },
+      { label: "None (Remove existing)", value: "none" }
+    ],
+    i18n: [
+      { label: "next-intl", value: "next-intl" },
+      { label: "next-international", value: "next-international" },
+      { label: "Lingui", value: "lingui" },
+      { label: "None (Remove existing)", value: "none" }
+    ]
+  };
+  const category = await selectPrompt({
+    title: "Which kind of integration would you like to add?",
+    options: [
+      { label: "Database", value: "database" },
+      { label: "Payments", value: "payments" },
+      { label: "Authentication", value: "auth" },
+      { label: "Email", value: "email" },
+      { label: "Styling", value: "styling" },
+      { label: "Testing", value: "testing" },
+      { label: "Internationalization", value: "i18n" }
+    ]
+  });
+  const options = integrationOptions[category];
+  if (!options) {
+    throw new Error(`No integration options found for category: ${category}`);
+  }
+  const selectedIntegration = await selectPrompt({
+    title: `Select ${category} integration:`,
+    options: options.map((opt) => ({
+      label: opt.label,
+      value: opt.value
+    }))
+  });
+  if (selectedIntegration === "none") {
+    const shouldRemove = await confirmPrompt({
+      title: `Are you sure you want to remove all ${category} integrations?`,
+      content: `This will remove all ${category}-related files and dependencies`,
+      defaultValue: false
+    });
+    if (shouldRemove && REMOVAL_CONFIGS[category]) {
+      await removeIntegration(cwd, REMOVAL_CONFIGS[category]);
+      return;
+    }
+  }
+  if (category === "database" && selectedIntegration === "drizzle") {
+    const option = options.find((opt) => opt.value === "drizzle");
+    if (!option?.subOptions) {
+      throw new Error("Database configuration not found");
+    }
+    const dbType = await selectPrompt({
+      title: "Select database type:",
+      options: option.subOptions.map((sub) => ({
+        label: sub.label,
+        value: sub.value
+      }))
+    });
+    if (dbType === "postgres") {
+      const postgresOption = option.subOptions.find((sub) => sub.value === "postgres");
+      if (!postgresOption?.providers) {
+        throw new Error("PostgreSQL providers not found");
+      }
+      const provider = await selectPrompt({
+        title: "Select database provider:",
+        options: postgresOption.providers.map((p) => ({
+          label: p,
+          value: p.toLowerCase()
+        }))
+      });
+      const config2 = {
+        ...INTEGRATION_CONFIGS.drizzle,
+        name: "drizzle",
+        dependencies: [
+          // @ts-expect-error TODO: fix strictNullChecks undefined
+          ...INTEGRATION_CONFIGS.drizzle.dependencies,
+          provider === "neon" ? "@neondatabase/serverless" : "postgres"
+        ],
+        files: [],
+        devDependencies: [],
+        scripts: {},
+        envVars: {}
+      };
+      await installIntegration(cwd, config2, isDev);
+      relinka(
+        "info",
+        `Selected ${selectedIntegration} for ${category} - Implementation coming soon!`
+      );
+      return;
+    }
+    await installIntegration(cwd, INTEGRATION_CONFIGS.drizzle, isDev);
+    relinka(
+      "info",
+      `Selected ${selectedIntegration} for ${category} - Implementation coming soon!`
+    );
+    return;
+  }
+  const integrationKey = selectedIntegration;
+  const config = INTEGRATION_CONFIGS[integrationKey];
+  if (!config) {
+    relinka("error", `Integration configuration not found for ${integrationKey}`);
+    return;
+  }
+  await installIntegration(cwd, config, isDev);
+  relinka("info", `Selected ${selectedIntegration} for ${category} - Implementation coming soon!`);
+  return;
+}

package/bin/app/init/mm-deprecated/editor-mod.d.ts

@@ -0,0 +1,18 @@
+import type { PackageJson } from "pkg-types";
+import type { IntegrationConfig, RemovalConfig } from "../../types/mod.js";
+/**
+ * Updates package.json fields with comprehensive options
+ * @param projectPath - Path to the project directory containing package.json
+ * @param options - Configuration options for the update
+ * @returns Promise resolving to true if successful, false otherwise
+ */
+export declare function updatePackageJson(projectPath: string, options?: {
+    /** Full or partial package.json fields to update */
+    fields?: Partial<PackageJson>;
+    /** Scripts to add or update */
+    scripts?: Record<string, string>;
+    /** Whether to throw errors instead of returning false */
+    throwOnError?: boolean;
+}): Promise<boolean>;
+export declare function installIntegration(cwd: string, config: IntegrationConfig, isDev: boolean): Promise<void>;
+export declare function removeIntegration(cwd: string, config: RemovalConfig): Promise<void>;