prisma-flare 1.0.0 → 1.1.1

package/dist/cli/db-create.cjs

@@ -23,9 +23,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/cli/db-create.ts
-var dotenv = __toESM(require("dotenv"), 1);
-
 // src/core/adapters/postgres.ts
 var PostgresAdapter = {
   name: "postgres",
@@ -33,26 +30,26 @@ var PostgresAdapter = {
     return url.startsWith("postgresql://") || url.startsWith("postgres://");
   },
   async create(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
       await client.connect();
       const checkRes = await client.query(
         `SELECT 1 FROM pg_database WHERE datname = $1`,
-        [config3.database]
+        [config.database]
       );
       if (checkRes.rowCount === 0) {
-        await client.query(`CREATE DATABASE "${config3.database}"`);
-        console.log(`\u2705 Database "${config3.database}" created successfully.`);
+        await client.query(`CREATE DATABASE "${config.database}"`);
+        console.log(`\u2705 Database "${config.database}" created successfully.`);
       } else {
-        console.log(`\u26A0\uFE0F  Database "${config3.database}" already exists.`);
+        console.log(`\u26A0\uFE0F  Database "${config.database}" already exists.`);
       }
     } catch (error) {
       console.error("\u274C Error creating database:", error);
@@ -62,13 +59,13 @@ var PostgresAdapter = {
     }
   },
   async drop(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
@@ -78,10 +75,10 @@ var PostgresAdapter = {
          FROM pg_stat_activity
          WHERE pg_stat_activity.datname = $1
          AND pid <> pg_backend_pid()`,
-        [config3.database]
+        [config.database]
       );
-      await client.query(`DROP DATABASE IF EXISTS "${config3.database}"`);
-      console.log(`\u2705 Database "${config3.database}" dropped successfully.`);
+      await client.query(`DROP DATABASE IF EXISTS "${config.database}"`);
+      console.log(`\u2705 Database "${config.database}" dropped successfully.`);
     } catch (error) {
       console.error("\u274C Error dropping database:", error);
       throw error;
@@ -183,44 +180,7 @@ 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) {

package/dist/cli/db-create.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
 
-// src/cli/db-create.ts
-import * as dotenv from "dotenv";
-
 // src/core/adapters/postgres.ts
 var PostgresAdapter = {
   name: "postgres",
@@ -10,26 +7,26 @@ var PostgresAdapter = {
     return url.startsWith("postgresql://") || url.startsWith("postgres://");
   },
   async create(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
       await client.connect();
       const checkRes = await client.query(
         `SELECT 1 FROM pg_database WHERE datname = $1`,
-        [config3.database]
+        [config.database]
       );
       if (checkRes.rowCount === 0) {
-        await client.query(`CREATE DATABASE "${config3.database}"`);
-        console.log(`\u2705 Database "${config3.database}" created successfully.`);
+        await client.query(`CREATE DATABASE "${config.database}"`);
+        console.log(`\u2705 Database "${config.database}" created successfully.`);
       } else {
-        console.log(`\u26A0\uFE0F  Database "${config3.database}" already exists.`);
+        console.log(`\u26A0\uFE0F  Database "${config.database}" already exists.`);
       }
     } catch (error) {
       console.error("\u274C Error creating database:", error);
@@ -39,13 +36,13 @@ var PostgresAdapter = {
     }
   },
   async drop(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
@@ -55,10 +52,10 @@ var PostgresAdapter = {
          FROM pg_stat_activity
          WHERE pg_stat_activity.datname = $1
          AND pid <> pg_backend_pid()`,
-        [config3.database]
+        [config.database]
       );
-      await client.query(`DROP DATABASE IF EXISTS "${config3.database}"`);
-      console.log(`\u2705 Database "${config3.database}" dropped successfully.`);
+      await client.query(`DROP DATABASE IF EXISTS "${config.database}"`);
+      console.log(`\u2705 Database "${config.database}" dropped successfully.`);
     } catch (error) {
       console.error("\u274C Error dropping database:", error);
       throw error;
@@ -160,44 +157,7 @@ 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) {

package/dist/cli/db-drop.cjs

@@ -24,7 +24,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli/db-drop.ts
-var dotenv = __toESM(require("dotenv"), 1);
 var readline = __toESM(require("readline"), 1);
 
 // src/core/adapters/postgres.ts
@@ -34,26 +33,26 @@ var PostgresAdapter = {
     return url.startsWith("postgresql://") || url.startsWith("postgres://");
   },
   async create(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
       await client.connect();
       const checkRes = await client.query(
         `SELECT 1 FROM pg_database WHERE datname = $1`,
-        [config3.database]
+        [config.database]
       );
       if (checkRes.rowCount === 0) {
-        await client.query(`CREATE DATABASE "${config3.database}"`);
-        console.log(`\u2705 Database "${config3.database}" created successfully.`);
+        await client.query(`CREATE DATABASE "${config.database}"`);
+        console.log(`\u2705 Database "${config.database}" created successfully.`);
       } else {
-        console.log(`\u26A0\uFE0F  Database "${config3.database}" already exists.`);
+        console.log(`\u26A0\uFE0F  Database "${config.database}" already exists.`);
       }
     } catch (error) {
       console.error("\u274C Error creating database:", error);
@@ -63,13 +62,13 @@ var PostgresAdapter = {
     }
   },
   async drop(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
@@ -79,10 +78,10 @@ var PostgresAdapter = {
          FROM pg_stat_activity
          WHERE pg_stat_activity.datname = $1
          AND pid <> pg_backend_pid()`,
-        [config3.database]
+        [config.database]
       );
-      await client.query(`DROP DATABASE IF EXISTS "${config3.database}"`);
-      console.log(`\u2705 Database "${config3.database}" dropped successfully.`);
+      await client.query(`DROP DATABASE IF EXISTS "${config.database}"`);
+      console.log(`\u2705 Database "${config.database}" dropped successfully.`);
     } catch (error) {
       console.error("\u274C Error dropping database:", error);
       throw error;
@@ -184,44 +183,7 @@ 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-drop.ts
-var config2 = loadConfig();
-dotenv.config({ path: config2.envPath });
 function confirm(question) {
   const rl = readline.createInterface({
     input: process.stdin,

package/dist/cli/db-drop.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 // src/cli/db-drop.ts
-import * as dotenv from "dotenv";
 import * as readline from "readline";
 
 // src/core/adapters/postgres.ts
@@ -11,26 +10,26 @@ var PostgresAdapter = {
     return url.startsWith("postgresql://") || url.startsWith("postgres://");
   },
   async create(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
       await client.connect();
       const checkRes = await client.query(
         `SELECT 1 FROM pg_database WHERE datname = $1`,
-        [config3.database]
+        [config.database]
       );
       if (checkRes.rowCount === 0) {
-        await client.query(`CREATE DATABASE "${config3.database}"`);
-        console.log(`\u2705 Database "${config3.database}" created successfully.`);
+        await client.query(`CREATE DATABASE "${config.database}"`);
+        console.log(`\u2705 Database "${config.database}" created successfully.`);
       } else {
-        console.log(`\u26A0\uFE0F  Database "${config3.database}" already exists.`);
+        console.log(`\u26A0\uFE0F  Database "${config.database}" already exists.`);
       }
     } catch (error) {
       console.error("\u274C Error creating database:", error);
@@ -40,13 +39,13 @@ var PostgresAdapter = {
     }
   },
   async drop(url) {
-    const config3 = parseDatabaseUrl(url);
+    const config = parseDatabaseUrl(url);
     const { Client } = await import("pg");
     const client = new Client({
-      user: config3.user,
-      password: config3.password,
-      host: config3.host,
-      port: config3.port,
+      user: config.user,
+      password: config.password,
+      host: config.host,
+      port: config.port,
       database: "postgres"
     });
     try {
@@ -56,10 +55,10 @@ var PostgresAdapter = {
          FROM pg_stat_activity
          WHERE pg_stat_activity.datname = $1
          AND pid <> pg_backend_pid()`,
-        [config3.database]
+        [config.database]
       );
-      await client.query(`DROP DATABASE IF EXISTS "${config3.database}"`);
-      console.log(`\u2705 Database "${config3.database}" dropped successfully.`);
+      await client.query(`DROP DATABASE IF EXISTS "${config.database}"`);
+      console.log(`\u2705 Database "${config.database}" dropped successfully.`);
     } catch (error) {
       console.error("\u274C Error dropping database:", error);
       throw error;
@@ -161,44 +160,7 @@ 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-drop.ts
-var config2 = loadConfig();
-dotenv.config({ path: config2.envPath });
 function confirm(question) {
   const rl = readline.createInterface({
     input: process.stdin,

package/dist/cli/db-migrate.cjs

@@ -25,7 +25,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/db-migrate.ts
 var import_child_process = require("child_process");
-var dotenv = __toESM(require("dotenv"), 1);
 
 // src/cli/generate-queries.ts
 var fs2 = __toESM(require("fs"), 1);
@@ -48,7 +47,7 @@ function findProjectRoot(currentDir) {
 function loadConfig(rootDir) {
   const projectRoot = rootDir || findProjectRoot(process.cwd());
   const configPath = path.join(projectRoot, "prisma-flare.config.json");
-  let config3 = {
+  let config = {
     modelsPath: "prisma/models",
     dbPath: "prisma/db",
     callbacksPath: "prisma/callbacks"
@@ -57,13 +56,13 @@ function loadConfig(rootDir) {
     try {
       const configFile = fs.readFileSync(configPath, "utf-8");
       const userConfig = JSON.parse(configFile);
-      config3 = { ...config3, ...userConfig };
+      config = { ...config, ...userConfig };
     } catch {
       console.warn("\u26A0\uFE0F Could not read prisma-flare.config.json, using defaults.");
     }
   }
   return {
-    ...config3
+    ...config
   };
 }
 
@@ -87,7 +86,7 @@ function parseRelations(schemaContent, models) {
       if (fieldMatch) {
         const fieldName = fieldMatch[1];
         const fieldType = fieldMatch[2];
-        const isArray = !!fieldMatch[3];
+        const _isArray = !!fieldMatch[3];
         if (models.includes(fieldType)) {
           const modelRelations = relations.get(modelName) || [];
           modelRelations.push({ fieldName, targetModel: fieldType });
@@ -100,7 +99,7 @@ function parseRelations(schemaContent, models) {
 }
 function generateQueries() {
   const rootDir = findProjectRoot(process.cwd());
-  const config3 = loadConfig(rootDir);
+  const config = loadConfig(rootDir);
   const schemaPath = path2.join(rootDir, "prisma", "schema.prisma");
   if (!fs2.existsSync(schemaPath)) {
     console.error(`\u274C Schema not found at ${schemaPath}`);
@@ -113,11 +112,11 @@ function generateQueries() {
   while ((match = modelRegex.exec(schemaContent)) !== null) {
     models.push(match[1]);
   }
-  const queriesDir = path2.join(rootDir, config3.modelsPath);
+  const queriesDir = path2.join(rootDir, config.modelsPath);
   if (!fs2.existsSync(queriesDir)) {
     fs2.mkdirSync(queriesDir, { recursive: true });
   }
-  const absDbPath = path2.join(rootDir, config3.dbPath);
+  const absDbPath = path2.join(rootDir, config.dbPath);
   let relativePathToDb = path2.relative(queriesDir, absDbPath);
   if (!relativePathToDb.startsWith(".")) relativePathToDb = "./" + relativePathToDb;
   relativePathToDb = relativePathToDb.replace(/\\/g, "/");
@@ -175,7 +174,7 @@ export default class ${model} extends FlareBuilder<'${modelCamel}'> {
   const relations = parseRelations(schemaContent, models);
   const getters = models.map((model) => {
     const modelCamel = toCamelCase(model);
-    const customPlural = config3.plurals?.[model];
+    const customPlural = config.plurals?.[model];
     const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
     return `  static get ${modelPlural}() {
     return new ${model}();
@@ -184,12 +183,12 @@ export default class ${model} extends FlareBuilder<'${modelCamel}'> {
   const registrationLines = [];
   models.forEach((model) => {
     const modelCamel = toCamelCase(model);
-    const customPlural = config3.plurals?.[model];
+    const customPlural = config.plurals?.[model];
     const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
     registrationLines.push(`modelRegistry.register('${modelCamel}', ${model});`);
     registrationLines.push(`modelRegistry.register('${modelPlural}', ${model});`);
   });
-  relations.forEach((rels, modelName) => {
+  relations.forEach((rels, _modelName) => {
     rels.forEach((rel) => {
       registrationLines.push(`modelRegistry.register('${rel.fieldName}', ${rel.targetModel});`);
     });
@@ -244,19 +243,19 @@ exports.DB = DB;
   }).join("\n");
   const gettersTypes = models.map((model) => {
     const modelCamel = toCamelCase(model);
-    const customPlural = config3.plurals?.[model];
+    const customPlural = config.plurals?.[model];
     const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
     return `  static get ${modelPlural}(): ${model};`;
   }).join("\n");
   const relationMapEntries = [];
   models.forEach((model) => {
     const modelCamel = toCamelCase(model);
-    const customPlural = config3.plurals?.[model];
+    const customPlural = config.plurals?.[model];
     const modelPlural = customPlural || (0, import_pluralize.default)(modelCamel);
     relationMapEntries.push(`    ${modelCamel}: ${model};`);
     relationMapEntries.push(`    ${modelPlural}: ${model};`);
   });
-  relations.forEach((rels, modelName) => {
+  relations.forEach((rels, _modelName) => {
     rels.forEach((rel) => {
       const entry = `    ${rel.fieldName}: ${rel.targetModel};`;
       if (!relationMapEntries.includes(entry)) {
@@ -288,8 +287,6 @@ ${gettersTypes}
 }
 
 // src/cli/db-migrate.ts
-var config2 = loadConfig();
-dotenv.config({ path: config2.envPath });
 function runMigrations() {
   const databaseUrl = process.env.DATABASE_URL;
   if (!databaseUrl) {