@prisma/cli-init 0.4.0 → 0.5.0

package/dist/index.js

@@ -21,14 +21,14 @@ import {
   url,
   withResolvers,
   y
-} from "./chunk-ASMCGOOW.js";
+} from "./chunk-7C5I22R2.js";
 import {
   credentialsFile,
   poll,
   printPpgInitOutput,
   requestOrThrow,
   successMessage
-} from "./chunk-SORRSNB3.js";
+} from "./chunk-OCHZ4DEX.js";
 import {
   __commonJS,
   __require,
@@ -1485,13 +1485,13 @@ var require_lockfile = __commonJS({
               if (lock3.released) {
                 return releasedCallback && releasedCallback(Object.assign(new Error("Lock is already released"), { code: "ERELEASED" }));
               }
-              unlock(file2, { ...options, realpath: false }, releasedCallback);
+              unlock2(file2, { ...options, realpath: false }, releasedCallback);
             });
           });
         });
       });
     }
-    function unlock(file, options, callback) {
+    function unlock2(file, options, callback) {
       options = {
         fs: fs3,
         realpath: true,
@@ -1544,7 +1544,7 @@ var require_lockfile = __commonJS({
       }
     });
     module.exports.lock = lock2;
-    module.exports.unlock = unlock;
+    module.exports.unlock = unlock2;
     module.exports.check = check2;
     module.exports.getLocks = getLocks;
   }
@@ -1629,7 +1629,7 @@ var require_proper_lockfile = __commonJS({
       const release = toSync(lockfile.lock)(file, toSyncOptions(options));
       return toSync(release);
     }
-    function unlock(file, options) {
+    function unlock2(file, options) {
       return toPromise(lockfile.unlock)(file, options);
     }
     function unlockSync(file, options) {
@@ -1643,7 +1643,7 @@ var require_proper_lockfile = __commonJS({
     }
     module.exports = lock2;
     module.exports.lock = lock2;
-    module.exports.unlock = unlock;
+    module.exports.unlock = unlock2;
     module.exports.lockSync = lockSync;
     module.exports.unlockSync = unlockSync;
     module.exports.check = check2;
@@ -2645,7 +2645,7 @@ async function getApp(port, dbServer, serverState) {
   const { debug } = serverState;
   const [{ Hono }, { accelerateRoute }, { utilityRoute }] = await Promise.all([
     import("hono/tiny"),
-    import("./accelerate-GABM6I4V.js"),
+    import("./accelerate-YEFEYVGD.js"),
     import("./utility-W6LOZZIT.js")
   ]);
   const app = new Hono();
@@ -2787,12 +2787,12 @@ ${JSON.stringify(issues, null, 2)}`);
     });
   }
   static async scan(options) {
-    const { debug } = options ?? {};
+    const { debug, globs } = options ?? {};
     const dataDirsPath = join(getDataDirPath(DEFAULT_NAME), "..");
     if (debug) {
       console.debug(`[State] scanning for server states in: ${dataDirsPath}`);
     }
-    const names = await readDirectoryNames(dataDirsPath);
+    const names = await readDirectoryNames(dataDirsPath, globs);
     if (debug) {
       console.debug(`[State] found server names: ${JSON.stringify(names)}`);
     }
@@ -2834,14 +2834,17 @@ var StatelessServerState = class extends ServerState {
 var StatefulServerState = class _StatefulServerState extends ServerState {
   #databaseDumpPath;
   #dataDirPath;
+  #lockfilePath;
   #pglitePath;
   #serverDumpPath;
+  #closed;
   #serverDump;
-  #unlock = null;
   constructor(options) {
     super({ ...options, persistenceMode: "stateful" });
+    this.#closed = false;
     this.#dataDirPath = getDataDirPath(this.name);
     this.#databaseDumpPath = join(this.#dataDirPath, "db_dump.bak");
+    this.#lockfilePath = join(this.#dataDirPath, ".lock");
     this.#pglitePath = join(this.#dataDirPath, ".pglite");
     this.#serverDump = options?.serverDump ?? null;
     this.#serverDumpPath = _StatefulServerState.getServerDumpPath(this.#dataDirPath);
@@ -2864,7 +2867,7 @@ var StatefulServerState = class _StatefulServerState extends ServerState {
       console.debug(`[State] using data directory: ${this.#dataDirPath}`);
     }
     try {
-      this.#unlock = await (0, import_proper_lockfile.lock)(this.#dataDirPath, { lockfilePath: join(this.#dataDirPath, ".lock") });
+      await (0, import_proper_lockfile.lock)(this.#dataDirPath, { lockfilePath: this.#lockfilePath });
       if (this.debug) {
         console.debug(`[State] obtained lock on: ${this.#dataDirPath}`);
       }
@@ -2891,17 +2894,19 @@ var StatefulServerState = class _StatefulServerState extends ServerState {
     }
   }
   async close() {
-    if (this.#unlock == null) {
+    if (this.#closed) {
       return;
     }
     try {
-      await this.#unlock();
-      this.#unlock = null;
+      await (0, import_proper_lockfile.unlock)(this.#dataDirPath, { lockfilePath: this.#lockfilePath });
+      this.#closed = true;
       if (this.debug) {
         console.debug(`[State] released lock on: ${this.#dataDirPath}`);
       }
     } catch (error) {
-      console.error(`[State] failed to release lock on: ${this.#dataDirPath}`);
+      if (this.debug) {
+        console.error(`[State] failed to release lock on: ${this.#dataDirPath}`, error);
+      }
       throw error;
     }
   }
@@ -2919,19 +2924,21 @@ var StatefulServerState = class _StatefulServerState extends ServerState {
 `, { encoding: "utf-8" });
   }
 };
-async function getServerStatus(name, options) {
+async function getServerStatus(nameOrState, options) {
   const { debug, onlyMetadata } = options || {};
+  const name = typeof nameOrState === "string" ? nameOrState : nameOrState.name;
+  const givenState = typeof nameOrState !== "string" ? nameOrState : void 0;
   const baseResult = {
-    databasePort: -1,
-    exports: void 0,
+    databasePort: givenState?.databasePort ?? -1,
+    exports: givenState?.exports,
     name,
-    pid: void 0,
-    port: -1,
-    shadowDatabasePort: -1,
+    pid: givenState?.pid,
+    port: givenState?.port ?? -1,
+    shadowDatabasePort: givenState?.shadowDatabasePort ?? -1,
     version: "1"
   };
   try {
-    const serverState = await ServerState.fromServerDump({ debug, name });
+    const serverState = givenState || await ServerState.fromServerDump({ debug, name });
     if (!serverState) {
       if (debug) {
         console.debug(`[State] no server state found for name: ${name}`);
@@ -2979,14 +2986,14 @@ async function getServerStatus(name, options) {
       return { ...baseResult, status: "not_running" };
     }
     const health = await healthResponse.json();
-    if (health.name !== name) {
+    if (health.name !== nameOrState) {
       if (debug) {
         console.debug(`[State] server state for "${name}" has mismatched health response: ${JSON.stringify(health)}`);
       }
       return { ...baseResult, status: "unknown" };
     }
     if (debug) {
-      console.debug(`[State] server state for "${name}" is live: ${JSON.stringify(health)}`);
+      console.debug(`[State] server state for "${nameOrState}" is live: ${JSON.stringify(health)}`);
     }
     return { ...baseResult, status: "running" };
   } catch (error) {
@@ -3145,6 +3152,10 @@ function printError(text) {
 }
 
 // src/Init.ts
+var isBun = (
+  // @ts-ignore
+  !!globalThis.Bun || !!globalThis.process?.versions?.bun
+);
 var defaultSchema = (props) => {
   const {
     datasourceProvider = "postgresql",
@@ -3169,7 +3180,6 @@ ${previewFeatures.length > 0 ? `  previewFeatures = [${previewFeatures.map((feat
 
 datasource db {
   provider = "${datasourceProvider}"
-  url      = env("DATABASE_URL")
 }
 `;
   if (withModel) {
@@ -3203,10 +3213,10 @@ model User {
   }
   return schema;
 };
-var defaultEnv = async (url2, comments = true) => {
+var defaultEnv = async (url2, debug = false, comments = true) => {
   if (url2 === void 0) {
     let created = false;
-    const state = await ServerState.fromServerDump() || (created = true, await ServerState.createExclusively({ persistenceMode: "stateful" }));
+    const state = await ServerState.fromServerDump({ debug }) || (created = true, await ServerState.createExclusively({ persistenceMode: "stateful", debug }));
     if (created) {
       await state.close();
     }
@@ -3214,12 +3224,14 @@ var defaultEnv = async (url2, comments = true) => {
       databasePort: state.databasePort,
       dryRun: true,
       port: state.port,
-      shadowDatabasePort: state.shadowDatabasePort
+      shadowDatabasePort: state.shadowDatabasePort,
+      debug
     });
     url2 = server.ppg.url;
   }
-  let env = comments ? `# Environment variables declared in this file are automatically made available to Prisma.
-# See the documentation for more detail: https://pris.ly/d/prisma-schema#accessing-environment-variables-from-the-schema
+  let env = comments ? `# Environment variables declared in this file are NOT automatically loaded by Prisma.
+# Please add \`import "dotenv/config";\` to your \`prisma.config.ts\` file, or use the Prisma CLI with Bun
+# to load environment variables from .env files: https://pris.ly/prisma-config-env-vars.
 
 # Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB and CockroachDB.
 # See the documentation for all the connection string options: https://pris.ly/d/connection-strings
@@ -3273,8 +3285,29 @@ var defaultGitIgnore = () => {
 .env
 `;
 };
-var defaultGeneratorProvider = "prisma-client-js";
+var defaultGeneratorProvider = "prisma-client";
 var defaultPreviewFeatures = [];
+function normalizePath(configPath) {
+  return JSON.stringify(configPath.replaceAll(path2.sep, "/"));
+}
+var defaultConfig = (props) => {
+  const { prismaFolder } = props;
+  const schemaPath = path2.relative(process.cwd(), path2.join(prismaFolder, "schema.prisma"));
+  const migrationsPath = path2.relative(process.cwd(), path2.join(prismaFolder, "migrations"));
+  return `import { defineConfig, env } from "prisma/config";
+
+export default defineConfig({
+  schema: ${normalizePath(schemaPath)},
+  migrations: {
+    path: ${normalizePath(migrationsPath)},
+  },
+  engine: "classic",
+  datasource: {
+    url: env("DATABASE_URL"),
+  },
+});
+`;
+};
 var Init = class _Init {
   static new() {
     return new _Init();
@@ -3338,7 +3371,8 @@ var Init = class _Init {
       "--name": String,
       "--non-interactive": Boolean,
       "--prompt": String,
-      "--vibe": String
+      "--vibe": String,
+      "--debug": Boolean
     });
     if (internals.isError(args) || args["--help"]) {
       return this.help();
@@ -3399,7 +3433,7 @@ var Init = class _Init {
     let generatedSchema;
     let generatedName;
     if (isPpgCommand) {
-      const PlatformCommands = await import("./_-WIN5AVS3.js");
+      const PlatformCommands = await import("./_-YBFA2SJO.js");
       const credentials = await credentialsFile.load();
       if (internals.isError(credentials))
         throw credentials;
@@ -3552,9 +3586,15 @@ var Init = class _Init {
     );
     const databaseUrl = prismaPostgresDatabaseUrl || url2;
     const warnings = [];
+    fs2.writeFileSync(
+      path2.join(outputDir, "prisma.config.ts"),
+      defaultConfig({
+        prismaFolder
+      })
+    );
     const envPath = path2.join(outputDir, ".env");
     if (!fs2.existsSync(envPath)) {
-      fs2.writeFileSync(envPath, await defaultEnv(databaseUrl));
+      fs2.writeFileSync(envPath, await defaultEnv(databaseUrl, args["--debug"]));
     } else {
       const envFile = fs2.readFileSync(envPath, { encoding: "utf8" });
       const config = dotenv.parse(envFile);
@@ -3565,10 +3605,13 @@ var Init = class _Init {
           )}`
         );
       } else {
-        fs2.appendFileSync(envPath, `
+        fs2.appendFileSync(
+          envPath,
+          `
 
 # This was inserted by \`prisma init\`:
-` + defaultEnv(databaseUrl));
+` + await defaultEnv(databaseUrl, args["--debug"])
+        );
       }
     }
     const gitignorePath = path2.join(outputDir, ".gitignore");
@@ -3594,6 +3637,9 @@ var Init = class _Init {
       console.error("Failed to append client path to .gitignore file, reason: ", e);
     }
     const steps = [];
+    if (!isBun) {
+      steps.push(`Install \`dotenv\`, and add \`import "dotenv/config";\` to your \`prisma.config.ts\` file to load environment variables from \`.env\`.`);
+    }
     const isPrismaDev = !args["--url"] && (datasourceProvider === "postgres" || datasourceProvider === "postgresql");
     if (isPrismaDev) {
       steps.push(
@@ -3629,9 +3675,14 @@ var Init = class _Init {
         "ORM"
       )} with scalable connection pooling, global caching, and a managed serverless Postgres database. Read: https://pris.ly/cli/beyond-orm`
     );
+    if (!isBun) {
+      warnings.push(`Environment variables declared in the \`.env\` file are NOT automatically loaded by Prisma.
+See: https://pris.ly/prisma-config-env-vars.`);
+    }
     const defaultOutput = `
 \u2714 Your Prisma schema was created at ${green("prisma/schema.prisma")}
-  You can now open it in your favorite editor.
+\u2714 Your Prisma config was created at ${green("prisma.config.ts")}
+  You can now open them in your favorite editor.
 ${warnings.length > 0 && internals.logger.should.warn() ? `
 ${warnings.join("\n")}
 ` : ""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli-init",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Init CLI for Prisma",
   "type": "module",
   "sideEffects": false,
@@ -36,7 +36,7 @@
     "tsup": "8.0.2",
     "typescript": "5.8.3",
     "vitest": "3.1.3",
-    "@prisma/dev": "0.9.0"
+    "@prisma/dev": "0.11.1"
   },
   "dependencies": {
     "@inquirer/prompts": "7.3.3",

package/dist/accelerate-GABM6I4V.js

@@ -1,221 +0,0 @@
-import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
-import {
-  Engine,
-  apiKeyValidator,
-  array,
-  handleEngineError,
-  integer,
-  literal,
-  looseObject,
-  minLength,
-  minValue,
-  number,
-  object,
-  optional,
-  pipe,
-  safeParse,
-  string,
-  union
-} from "./chunk-ASMCGOOW.js";
-import "./chunk-YX4UTTNJ.js";
-
-// ../../dev/server/src/accelerate.ts
-import { Hono } from "hono/tiny";
-import { validator } from "hono/validator";
-
-// ../../dev/server/src/caching.ts
-var invalidateInputSchema = object({
-  tags: union([pipe(array(string()), minLength(1)), literal("all")])
-});
-async function assertInvalidateInput(ctx) {
-  const { output, success } = safeParse(invalidateInputSchema, await ctx.req.json(), { abortEarly: true });
-  if (!success) {
-    return ctx.text("Invalid input", 400);
-  }
-  return output;
-}
-
-// ../../dev/server/src/schema.ts
-import { Buffer } from "buffer";
-var SCHEMAS_BY_HASH = /* @__PURE__ */ new Map();
-async function hashSchema(base64Schema) {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(base64Schema);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  const hashHex = hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  return hashHex;
-}
-function assertSchema(ctx) {
-  const schemaHash = ctx.req.param("schemaHash");
-  const schemas = SCHEMAS_BY_HASH.get(schemaHash);
-  if (schemas == null) {
-    return ctx.json({ EngineNotStarted: { reason: "SchemaMissing" } }, 404);
-  }
-  return { schemaHash, schemas };
-}
-var datasourceBlockRegex = /datasource\s+db\s+\{\s*provider\s*=\s*"postgres(!?ql)?"\s+url\s*=\s*.+\s*\}/;
-async function overrideDatasource(base64Schema, connectionString) {
-  const schema = Buffer.from(base64Schema, "base64").toString("utf8");
-  const override = `datasource db {
-	provider = "postgresql"
-	url = "${connectionString.toString()}"
-}`;
-  const schemaWithOverride = schema.replace(datasourceBlockRegex, override);
-  const overrideHash = await hashSchema(schemaWithOverride);
-  return {
-    base64Override: Buffer.from(schemaWithOverride, "utf8").toString("base64"),
-    overrideHash
-  };
-}
-
-// ../../dev/server/src/tracing.ts
-function getTracingHeaders(ctx) {
-  const { req } = ctx;
-  return {
-    traceparent: req.header("traceparent"),
-    ["X-capture-telemetry"]: req.header("X-capture-telemetry")
-  };
-}
-
-// ../../dev/server/src/transaction.ts
-var transactionOptionsSchema = object({
-  isolation_level: optional(string()),
-  max_wait: pipe(number(), integer(), minValue(0)),
-  timeout: pipe(number(), integer(), minValue(0))
-});
-async function assertTransactionOptions(ctx) {
-  const { issues, output, success } = safeParse(transactionOptionsSchema, await ctx.req.json(), { abortEarly: true });
-  if (!success) {
-    return ctx.json({ EngineNotStarted: { reason: "InvalidRequest", issues } }, 400);
-  }
-  return output;
-}
-var transactionSchema = looseObject({
-  id: union([string(), number()])
-});
-function assertTransaction(thing, ctx) {
-  const { output, success } = safeParse(transactionSchema, thing);
-  if (!success) {
-    return ctx.json({ EngineMalfunction: {} }, 500);
-  }
-  return output;
-}
-
-// ../../dev/server/src/accelerate.ts
-var accelerateRoute = new Hono();
-accelerateRoute.post("/invalidate", validator("header", apiKeyValidator), async (ctx) => {
-  const invlidateInput = await assertInvalidateInput(ctx);
-  if (invlidateInput instanceof Response) {
-    return invlidateInput;
-  }
-  return ctx.body(null);
-});
-var SCHEMAFUL_BASE_PATH = "/:clientVersion/:schemaHash";
-var schemafulRoute = accelerateRoute.basePath(SCHEMAFUL_BASE_PATH);
-accelerateRoute.route("/", schemafulRoute);
-var GRAPHQL_PATHS = ["/graphql", "/itx/:transactionId/graphql"];
-schemafulRoute.on("POST", [...GRAPHQL_PATHS], validator("header", apiKeyValidator), async (ctx) => {
-  const { req } = ctx;
-  try {
-    const engine = await getEngine(ctx);
-    if (engine instanceof Response) {
-      return engine;
-    }
-    const query = await req.text();
-    const transactionId = req.param("transactionId");
-    const results = await engine.request(query, {
-      ...getTracingHeaders(ctx),
-      ["X-transaction-id"]: transactionId
-    });
-    return ctx.text(results);
-  } catch (error) {
-    return handleEngineError(error, ctx);
-  }
-});
-schemafulRoute.basePath("/itx/:transactionId").on("POST", ["/commit", "/rollback"], validator("header", apiKeyValidator), async (ctx) => {
-  const { req } = ctx;
-  try {
-    const engine = await getEngine(ctx);
-    if (engine instanceof Response) {
-      return engine;
-    }
-    const action = req.routePath.split("/").filter(Boolean).at(-1);
-    const method = `${action}Transaction`;
-    const transactionId = req.param("transactionId");
-    const response = await engine[method](transactionId, getTracingHeaders(ctx));
-    return ctx.json(response);
-  } catch (error) {
-    return handleEngineError(error, ctx);
-  }
-});
-schemafulRoute.put("/schema", validator("header", apiKeyValidator), async (ctx) => {
-  const { req } = ctx;
-  const base64Schema = await req.text();
-  if (!base64Schema) {
-    return ctx.text("Missing schema", 400);
-  }
-  const schemaHash = req.param("schemaHash");
-  const schemas = SCHEMAS_BY_HASH.get(schemaHash);
-  if (schemas == null) {
-    if (schemaHash !== await hashSchema(base64Schema)) {
-      return ctx.text("Schema hash mismatch", 400);
-    }
-    const override = await overrideDatasource(base64Schema, ctx.get("db").prismaORMConnectionString);
-    SCHEMAS_BY_HASH.set(schemaHash, { base64Original: base64Schema, ...override });
-    return ctx.text(schemaHash);
-  }
-  if (base64Schema !== schemas.base64Original) {
-    return ctx.text("Schema mismatch", 400);
-  }
-  return ctx.text(schemaHash);
-});
-schemafulRoute.post("/transaction/start", validator("header", apiKeyValidator), async (ctx) => {
-  const { req } = ctx;
-  const transactionOptions = await assertTransactionOptions(ctx);
-  if (transactionOptions instanceof Response) {
-    return transactionOptions;
-  }
-  try {
-    const engine = await getEngine(ctx);
-    if (engine instanceof Response) {
-      return engine;
-    }
-    const response = await engine.startTransaction(transactionOptions, getTracingHeaders(ctx));
-    const transaction = assertTransaction(response, ctx);
-    if (transaction instanceof Response) {
-      return transaction;
-    }
-    const { id } = transaction;
-    const clientVersion = req.param("clientVersion");
-    const port = ctx.get("port");
-    const protocol = ctx.get("protocol");
-    const schemaHash = req.param("schemaHash");
-    return ctx.json({
-      ...response,
-      "data-proxy": {
-        endpoint: `${protocol}://localhost:${port}/${clientVersion}/${schemaHash}/itx/${id}`
-      }
-    });
-  } catch (error) {
-    return handleEngineError(error, ctx);
-  }
-});
-async function getEngine(ctx) {
-  const { req } = ctx;
-  const schema = assertSchema(ctx);
-  if (schema instanceof Response) {
-    return schema;
-  }
-  const { base64Override, overrideHash } = schema.schemas;
-  return await Engine.get({
-    base64Schema: base64Override,
-    clientVersion: process.env.PRISMA_DEV_FORCE_CLIENT_VERSION || req.param("clientVersion"),
-    debug: ctx.get("debug"),
-    platform: ctx.get("platform"),
-    schemaHash: overrideHash
-  });
-}
-export {
-  accelerateRoute
-};