@flaredev/cli 0.7.0 → 0.7.2

package/dist/index.js

@@ -4160,10 +4160,17 @@ ${result.output.trim()}`);
 import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync14, readdirSync as readdirSync8, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname11, join as join21, relative as relative2 } from "path";
 import pc17 from "picocolors";
-var TRACKED = ["lib/resource"];
+var TRACKED = ["lib", "components"];
+var PER_APP = /__APP_NAME__|__PM__|__THEME__|__COMPAT_DATE__/;
+var WRITTEN_PER_APP = /* @__PURE__ */ new Set(["lib/auth-config.ts"]);
 var prunedOn = (path, stack) => stack === "next" && CLOUDFLARE_ONLY.some((only) => path === only || path.startsWith(`${only}/`));
 function upstreamFile(path, stack) {
-  if (prunedOn(path, stack)) return void 0;
+  if (prunedOn(path, stack) || WRITTEN_PER_APP.has(path)) return void 0;
+  const found = locate(path, stack);
+  if (found && PER_APP.test(readFileSync14(found, "utf8"))) return void 0;
+  return found;
+}
+function locate(path, stack) {
   const candidates = stack === "next" ? [join21(templatesDir, "next", path), join21(templatesDir, "app", path)] : [join21(templatesDir, "app", path)];
   return candidates.find((candidate) => existsSync22(candidate));
 }
@@ -5205,6 +5212,8 @@ ${pc22.red("Out of sync:")} ${stale} file(s) would change. Run ${pc22.bold("flar
 }
 
 // src/commands/user-role.ts
+import { rmSync as rmSync9, writeFileSync as writeFileSync21 } from "fs";
+import { join as join28 } from "path";
 import pc23 from "picocolors";
 var ROLE = /^[a-z][a-z0-9_-]{0,31}$/;
 var EMAIL = /^[^\s@'"\\]+@[^\s@'"\\]+\.[^\s@'"\\]+$/;
@@ -5217,6 +5226,7 @@ async function setUserRole(email, role, options2 = {}) {
   const log2 = options2.log ?? ((message) => console.log(message));
   const appRoot = findAppRoot(options2.cwd ?? process.cwd());
   const sql2 = userRoleSql(email, role);
+  if (readStack(appRoot) === "next") return setUserRoleOnPrisma(appRoot, email, role, log2);
   const roles = await listRoles(options2);
   if (roles && !roles.includes(role)) {
     log2(pc23.red(`No role "${role}" is registered. Known roles: ${roles.join(", ") || "none"}.`));
@@ -5240,13 +5250,45 @@ ${result.output.trim()}`);
   log2(pc23.green(`${updated[0].email} now has role "${updated[0].role}" (${options2.remote ? "remote" : "local"}).`));
   return 0;
 }
+async function setUserRoleOnPrisma(appRoot, email, role, log2) {
+  const runner = join28(appRoot, ".flare-role-runner.mts");
+  const script = [
+    `import "dotenv/config";`,
+    `import { prisma } from "./lib/db";`,
+    "",
+    `const client = prisma as unknown as { user: { updateMany(args: unknown): Promise<{ count: number }> }; $disconnect(): Promise<void> };`,
+    `const { count } = await client.user.updateMany({`,
+    `  where: { email: { equals: ${JSON.stringify(email)}, mode: "insensitive" } },`,
+    `  data: { role: ${JSON.stringify(role)} },`,
+    `});`,
+    `await client.$disconnect();`,
+    `// 3 means "no account with that email", which the CLI turns into a useful message.`,
+    `if (count === 0) process.exit(3);`,
+    ""
+  ].join("\n");
+  writeFileSync21(runner, script);
+  try {
+    const tsx = resolveBin(appRoot, "tsx", "tsx");
+    const code = await runNode([tsx, runner], appRoot);
+    if (code === 3) {
+      log2(pc23.red(`No account with the email ${email}.`));
+      log2(pc23.dim("Sign up first, then set the role."));
+      return 1;
+    }
+    if (code !== 0) return code;
+    log2(pc23.green(`\u2714 ${email} is now ${role}.`));
+    return 0;
+  } finally {
+    rmSync9(runner, { force: true });
+  }
+}
 
 // src/utils/install.ts
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync26, readFileSync as readFileSync17, readdirSync as readdirSync10 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function expectedPackages(dir) {
-  const npmLock = join28(dir, "package-lock.json");
+  const npmLock = join29(dir, "package-lock.json");
   if (existsSync26(npmLock)) {
     try {
       const lock = JSON.parse(readFileSync17(npmLock, "utf8"));
@@ -5255,7 +5297,7 @@ function expectedPackages(dir) {
       return 0;
     }
   }
-  const pnpmLock = join28(dir, "pnpm-lock.yaml");
+  const pnpmLock = join29(dir, "pnpm-lock.yaml");
   if (existsSync26(pnpmLock)) {
     try {
       const text = readFileSync17(pnpmLock, "utf8");
@@ -5268,7 +5310,7 @@ function expectedPackages(dir) {
   return 0;
 }
 function installedPackages(dir) {
-  const root = join28(dir, "node_modules");
+  const root = join29(dir, "node_modules");
   if (!existsSync26(root)) return 0;
   let total = 0;
   try {
@@ -5276,7 +5318,7 @@ function installedPackages(dir) {
       if (!entry.isDirectory() || entry.name === ".bin") continue;
       if (entry.name.startsWith("@")) {
         try {
-          total += readdirSync10(join28(root, entry.name)).length;
+          total += readdirSync10(join29(root, entry.name)).length;
         } catch {
         }
       } else if (entry.name !== ".pnpm" && entry.name !== ".vite") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flaredev/cli",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "The flare command-line tool: create, generate, migrate, and deploy Flare apps",
   "license": "MIT",
   "author": "Muke Johnbaptist",
@@ -41,7 +41,7 @@
     "jiti": "^2.7.0",
     "jsonc-parser": "^3.3.1",
     "picocolors": "^1.1.1",
-    "@flaredev/core": "0.7.0"
+    "@flaredev/core": "0.7.2"
   },
   "engines": {
     "node": ">=22"

package/templates/next/lib/storage.ts

@@ -21,10 +21,26 @@ const client = new AwsClient({
 
 const endpoint = `${process.env.R2_ENDPOINT ?? ""}/${process.env.R2_BUCKET ?? ""}`;
 
+/**
+ * A key as a URL path.
+ *
+ * Each segment is escaped on its own, so the slashes in "products/2026/09/a.png" stay
+ * slashes. Escaping the whole key would turn them into %2F, which is a different object
+ * name to S3 even where a particular server is forgiving about it.
+ */
+const path = (key: string) => key.split("/").map(encodeURIComponent).join("/");
+
+/** Raise a bucket error rather than letting a failed write look like a successful one. */
+async function ok(response: Response, doing: string, key: string): Promise<Response> {
+  if (response.ok) return response;
+  const detail = await response.text().catch(() => "");
+  throw new Error(`Storage ${doing} failed for "${key}": ${response.status} ${detail.slice(0, 300)}`);
+}
+
 /** The bucket, shaped the way @flaredev/core expects, over plain HTTP calls. */
 const bucket = {
   async get(key: string) {
-    const response = await client.fetch(`${endpoint}/${encodeURIComponent(key)}`);
+    const response = await client.fetch(`${endpoint}/${path(key)}`);
     if (!response.ok || !response.body) return null;
     return {
       body: response.body,
@@ -35,15 +51,25 @@ const bucket = {
     };
   },
   async put(key: string, value: ReadableStream | ArrayBuffer | string | null, options?: { httpMetadata?: { contentType?: string } }) {
-    await client.fetch(`${endpoint}/${encodeURIComponent(key)}`, {
-      method: "PUT",
-      body: value,
-      headers: options?.httpMetadata?.contentType ? { "content-type": options.httpMetadata.contentType } : undefined,
-    });
+    // S3 needs a Content-Length, and a stream has no length to send — it answers
+    // "411 MissingContentLength" and stores nothing. Uploads are capped by the field's
+    // own maxBytes long before they reach here, so reading one into memory is safe and
+    // is what makes the length known.
+    //
+    // The length is set by hand rather than left to fetch. Next patches the global
+    // fetch, and in that runtime it does not derive content-length even from a buffered
+    // body — so S3 still answers 411 and stores nothing. Buffering everything through
+    // Response keeps one path for streams, buffers and strings alike.
+    const body = value === null ? new ArrayBuffer(0) : await new Response(value as BodyInit).arrayBuffer();
+    const headers: Record<string, string> = { "content-length": String(body.byteLength) };
+    if (options?.httpMetadata?.contentType) headers["content-type"] = options.httpMetadata.contentType;
+    await ok(await client.fetch(`${endpoint}/${path(key)}`, { method: "PUT", body, headers }), "upload", key);
   },
   async delete(keys: string | string[]) {
     for (const key of [keys].flat()) {
-      await client.fetch(`${endpoint}/${encodeURIComponent(key)}`, { method: "DELETE" });
+      const response = await client.fetch(`${endpoint}/${path(key)}`, { method: "DELETE" });
+      // S3 answers 204 for a key that was never there, which is the outcome we wanted.
+      if (response.status !== 404) await ok(response, "delete", key);
     }
   },
 };