prisma-flare 1.0.0

package/dist/cli/db-create.cjs

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/db-create.ts
+var dotenv = __toESM(require("dotenv"), 1);
+
+// src/core/adapters/postgres.ts
+var PostgresAdapter = {
+  name: "postgres",
+  matches(url) {
+    return url.startsWith("postgresql://") || url.startsWith("postgres://");
+  },
+  async create(url) {
+    const config3 = parseDatabaseUrl(url);
+    const { Client } = await import("pg");
+    const client = new Client({
+      user: config3.user,
+      password: config3.password,
+      host: config3.host,
+      port: config3.port,
+      database: "postgres"
+    });
+    try {
+      await client.connect();
+      const checkRes = await client.query(
+        `SELECT 1 FROM pg_database WHERE datname = $1`,
+        [config3.database]
+      );
+      if (checkRes.rowCount === 0) {
+        await client.query(`CREATE DATABASE "${config3.database}"`);
+        console.log(`\u2705 Database "${config3.database}" created successfully.`);
+      } else {
+        console.log(`\u26A0\uFE0F  Database "${config3.database}" already exists.`);
+      }
+    } catch (error) {
+      console.error("\u274C Error creating database:", error);
+      throw error;
+    } finally {
+      await client.end();
+    }
+  },
+  async drop(url) {
+    const config3 = parseDatabaseUrl(url);
+    const { Client } = await import("pg");
+    const client = new Client({
+      user: config3.user,
+      password: config3.password,
+      host: config3.host,
+      port: config3.port,
+      database: "postgres"
+    });
+    try {
+      await client.connect();
+      await client.query(
+        `SELECT pg_terminate_backend(pg_stat_activity.pid)
+         FROM pg_stat_activity
+         WHERE pg_stat_activity.datname = $1
+         AND pid <> pg_backend_pid()`,
+        [config3.database]
+      );
+      await client.query(`DROP DATABASE IF EXISTS "${config3.database}"`);
+      console.log(`\u2705 Database "${config3.database}" dropped successfully.`);
+    } catch (error) {
+      console.error("\u274C Error dropping database:", error);
+      throw error;
+    } finally {
+      await client.end();
+    }
+  }
+};
+function parseDatabaseUrl(url) {
+  const regex = /postgres(?:ql)?:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)(\?.*)?/;
+  const match = url.match(regex);
+  if (!match) {
+    throw new Error("Invalid PostgreSQL connection string");
+  }
+  return {
+    user: decodeURIComponent(match[1]),
+    password: decodeURIComponent(match[2]),
+    host: match[3],
+    port: parseInt(match[4], 10),
+    database: match[5]
+  };
+}
+
+// src/core/adapters/sqlite.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var SqliteAdapter = {
+  name: "sqlite",
+  matches(url) {
+    return url.startsWith("file:");
+  },
+  async create(url) {
+    const filePath = parseSqliteUrl(url);
+    const dir = path.dirname(filePath);
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, "");
+        console.log(`\u2705 SQLite database created at "${filePath}"`);
+      } else {
+        console.log(`\u26A0\uFE0F  SQLite database already exists at "${filePath}"`);
+      }
+    } catch (error) {
+      console.error("\u274C Error creating SQLite database:", error);
+      throw error;
+    }
+  },
+  async drop(url) {
+    const filePath = parseSqliteUrl(url);
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        console.log(`\u2705 SQLite database at "${filePath}" dropped successfully.`);
+      } else {
+        console.log(`\u26A0\uFE0F  SQLite database does not exist at "${filePath}"`);
+      }
+      if (fs.existsSync(`${filePath}-journal`)) {
+        fs.unlinkSync(`${filePath}-journal`);
+      }
+      if (fs.existsSync(`${filePath}-wal`)) {
+        fs.unlinkSync(`${filePath}-wal`);
+      }
+      if (fs.existsSync(`${filePath}-shm`)) {
+        fs.unlinkSync(`${filePath}-shm`);
+      }
+    } catch (error) {
+      console.error("\u274C Error dropping SQLite database:", error);
+      throw error;
+    }
+  }
+};
+function parseSqliteUrl(url) {
+  let cleanPath = url.replace(/^file:/, "");
+  if (!path.isAbsolute(cleanPath)) {
+    cleanPath = path.resolve(process.cwd(), cleanPath);
+  }
+  return cleanPath;
+}
+
+// src/core/adapters/index.ts
+var AdapterRegistry = class {
+  constructor() {
+    this.adapters = [];
+  }
+  register(adapter) {
+    this.adapters.push(adapter);
+  }
+  getAdapter(url) {
+    const adapter = this.adapters.find((a) => a.matches(url));
+    if (!adapter) {
+      throw new Error(`No database adapter found for URL: ${url}`);
+    }
+    return adapter;
+  }
+};
+var registry = new AdapterRegistry();
+registry.register(PostgresAdapter);
+registry.register(SqliteAdapter);
+
+// src/cli/config.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+function findProjectRoot(currentDir) {
+  if (fs2.existsSync(path2.join(currentDir, "package.json"))) {
+    return currentDir;
+  }
+  const parentDir = path2.dirname(currentDir);
+  if (parentDir === currentDir) {
+    throw new Error("Could not find package.json");
+  }
+  return findProjectRoot(parentDir);
+}
+function loadConfig(rootDir) {
+  const projectRoot = rootDir || findProjectRoot(process.cwd());
+  const configPath = path2.join(projectRoot, "prisma-flare.config.json");
+  let config3 = {
+    modelsPath: "prisma/models",
+    dbPath: "prisma/db",
+    callbacksPath: "prisma/callbacks"
+  };
+  if (fs2.existsSync(configPath)) {
+    try {
+      const configFile = fs2.readFileSync(configPath, "utf-8");
+      const userConfig = JSON.parse(configFile);
+      config3 = { ...config3, ...userConfig };
+    } catch {
+      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
+    }
+  }
+  return {
+    ...config3
+  };
+}
+
+// src/cli/db-create.ts
+var config2 = loadConfig();
+dotenv.config({ path: config2.envPath });
+async function createDatabase() {
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    console.error("\u274C DATABASE_URL environment variable is not set");
+    process.exit(1);
+  }
+  try {
+    const adapter = registry.getAdapter(databaseUrl);
+    console.log(`\u2713 Using adapter: ${adapter.name}`);
+    await adapter.create(databaseUrl);
+    process.exit(0);
+  } catch (error) {
+    console.error("\u274C Error creating database:", error);
+    process.exit(1);
+  }
+}
+createDatabase();

package/dist/cli/db-create.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/db-create.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/db-create.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+// src/cli/db-create.ts
+import * as dotenv from "dotenv";
+
+// src/core/adapters/postgres.ts
+var PostgresAdapter = {
+  name: "postgres",
+  matches(url) {
+    return url.startsWith("postgresql://") || url.startsWith("postgres://");
+  },
+  async create(url) {
+    const config3 = parseDatabaseUrl(url);
+    const { Client } = await import("pg");
+    const client = new Client({
+      user: config3.user,
+      password: config3.password,
+      host: config3.host,
+      port: config3.port,
+      database: "postgres"
+    });
+    try {
+      await client.connect();
+      const checkRes = await client.query(
+        `SELECT 1 FROM pg_database WHERE datname = $1`,
+        [config3.database]
+      );
+      if (checkRes.rowCount === 0) {
+        await client.query(`CREATE DATABASE "${config3.database}"`);
+        console.log(`\u2705 Database "${config3.database}" created successfully.`);
+      } else {
+        console.log(`\u26A0\uFE0F  Database "${config3.database}" already exists.`);
+      }
+    } catch (error) {
+      console.error("\u274C Error creating database:", error);
+      throw error;
+    } finally {
+      await client.end();
+    }
+  },
+  async drop(url) {
+    const config3 = parseDatabaseUrl(url);
+    const { Client } = await import("pg");
+    const client = new Client({
+      user: config3.user,
+      password: config3.password,
+      host: config3.host,
+      port: config3.port,
+      database: "postgres"
+    });
+    try {
+      await client.connect();
+      await client.query(
+        `SELECT pg_terminate_backend(pg_stat_activity.pid)
+         FROM pg_stat_activity
+         WHERE pg_stat_activity.datname = $1
+         AND pid <> pg_backend_pid()`,
+        [config3.database]
+      );
+      await client.query(`DROP DATABASE IF EXISTS "${config3.database}"`);
+      console.log(`\u2705 Database "${config3.database}" dropped successfully.`);
+    } catch (error) {
+      console.error("\u274C Error dropping database:", error);
+      throw error;
+    } finally {
+      await client.end();
+    }
+  }
+};
+function parseDatabaseUrl(url) {
+  const regex = /postgres(?:ql)?:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/([^?]+)(\?.*)?/;
+  const match = url.match(regex);
+  if (!match) {
+    throw new Error("Invalid PostgreSQL connection string");
+  }
+  return {
+    user: decodeURIComponent(match[1]),
+    password: decodeURIComponent(match[2]),
+    host: match[3],
+    port: parseInt(match[4], 10),
+    database: match[5]
+  };
+}
+
+// src/core/adapters/sqlite.ts
+import * as fs from "fs";
+import * as path from "path";
+var SqliteAdapter = {
+  name: "sqlite",
+  matches(url) {
+    return url.startsWith("file:");
+  },
+  async create(url) {
+    const filePath = parseSqliteUrl(url);
+    const dir = path.dirname(filePath);
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, "");
+        console.log(`\u2705 SQLite database created at "${filePath}"`);
+      } else {
+        console.log(`\u26A0\uFE0F  SQLite database already exists at "${filePath}"`);
+      }
+    } catch (error) {
+      console.error("\u274C Error creating SQLite database:", error);
+      throw error;
+    }
+  },
+  async drop(url) {
+    const filePath = parseSqliteUrl(url);
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+        console.log(`\u2705 SQLite database at "${filePath}" dropped successfully.`);
+      } else {
+        console.log(`\u26A0\uFE0F  SQLite database does not exist at "${filePath}"`);
+      }
+      if (fs.existsSync(`${filePath}-journal`)) {
+        fs.unlinkSync(`${filePath}-journal`);
+      }
+      if (fs.existsSync(`${filePath}-wal`)) {
+        fs.unlinkSync(`${filePath}-wal`);
+      }
+      if (fs.existsSync(`${filePath}-shm`)) {
+        fs.unlinkSync(`${filePath}-shm`);
+      }
+    } catch (error) {
+      console.error("\u274C Error dropping SQLite database:", error);
+      throw error;
+    }
+  }
+};
+function parseSqliteUrl(url) {
+  let cleanPath = url.replace(/^file:/, "");
+  if (!path.isAbsolute(cleanPath)) {
+    cleanPath = path.resolve(process.cwd(), cleanPath);
+  }
+  return cleanPath;
+}
+
+// src/core/adapters/index.ts
+var AdapterRegistry = class {
+  constructor() {
+    this.adapters = [];
+  }
+  register(adapter) {
+    this.adapters.push(adapter);
+  }
+  getAdapter(url) {
+    const adapter = this.adapters.find((a) => a.matches(url));
+    if (!adapter) {
+      throw new Error(`No database adapter found for URL: ${url}`);
+    }
+    return adapter;
+  }
+};
+var registry = new AdapterRegistry();
+registry.register(PostgresAdapter);
+registry.register(SqliteAdapter);
+
+// src/cli/config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function findProjectRoot(currentDir) {
+  if (fs2.existsSync(path2.join(currentDir, "package.json"))) {
+    return currentDir;
+  }
+  const parentDir = path2.dirname(currentDir);
+  if (parentDir === currentDir) {
+    throw new Error("Could not find package.json");
+  }
+  return findProjectRoot(parentDir);
+}
+function loadConfig(rootDir) {
+  const projectRoot = rootDir || findProjectRoot(process.cwd());
+  const configPath = path2.join(projectRoot, "prisma-flare.config.json");
+  let config3 = {
+    modelsPath: "prisma/models",
+    dbPath: "prisma/db",
+    callbacksPath: "prisma/callbacks"
+  };
+  if (fs2.existsSync(configPath)) {
+    try {
+      const configFile = fs2.readFileSync(configPath, "utf-8");
+      const userConfig = JSON.parse(configFile);
+      config3 = { ...config3, ...userConfig };
+    } catch {
+      console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
+    }
+  }
+  return {
+    ...config3
+  };
+}
+
+// src/cli/db-create.ts
+var config2 = loadConfig();
+dotenv.config({ path: config2.envPath });
+async function createDatabase() {
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    console.error("\u274C DATABASE_URL environment variable is not set");
+    process.exit(1);
+  }
+  try {
+    const adapter = registry.getAdapter(databaseUrl);
+    console.log(`\u2713 Using adapter: ${adapter.name}`);
+    await adapter.create(databaseUrl);
+    process.exit(0);
+  } catch (error) {
+    console.error("\u274C Error creating database:", error);
+    process.exit(1);
+  }
+}
+createDatabase();