@lunora/cli 1.0.0-alpha.8 → 1.0.0-alpha.81

package/dist/packem_chunks/handler.mjs

@@ -1,10 +1,11 @@
 import { existsSync } from 'node:fs';
 import { findWranglerFile } from '@lunora/config';
-import { join } from '@visulima/path';
-import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
-import { t as tuiSelect } from '../packem_shared/tui-prompts-XHFxlOg5.mjs';
-import { n as normalizeFeature, E as EMAIL_ITEM, D as DEFAULT_AUTH_ITEM, p as promptAuthProvider, A as AUTH_PROVIDER_OPTIONS } from '../packem_shared/features-ocSSpZtS.mjs';
-import { r as runAddCommand } from '../packem_shared/commands-DqsEzojt.mjs';
+import { join, basename } from '@visulima/path';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
+import { v as validateOutputFormat, i as isJsonFormat, p as printJson, l as loggerForFormat } from '../packem_shared/output-format-B4642rjE.mjs';
+import { t as tuiText, a as tuiSelect } from '../packem_shared/tui-prompts-BjEN8XgP.mjs';
+import { n as normalizeFeature, E as EMAIL_ITEM, s as sanitizeBucketName, d as deriveBucketName, p as promptBucketName, r as resolveTypedDestination, M as MAIL_DESTINATION_PROMPT, a as sanitizeDatabaseName, b as deriveDatabaseName, c as promptDatabaseName, D as DEFAULT_AUTH_ITEM, e as promptAuthProvider, A as AUTH_PROVIDER_OPTIONS, w as withStorageBucketName, f as withMailDestination, g as withAuthDatabaseName } from '../packem_shared/storage-DEXpJkXh.mjs';
+import { r as runAddCommand } from '../packem_shared/commands-ClEvcz3V.mjs';
 
 const providerToItem = (provider) => {
   const value = provider.trim().toLowerCase();
@@ -28,6 +29,51 @@ const resolveAuthItem = async (options) => {
   const select = options.promptSelect ?? ((message, choices, settings) => tuiSelect(message, choices, settings));
   return promptAuthProvider(select);
 };
+const textPrompt = (options) => options.promptText ?? ((message, settings) => tuiText(message, settings));
+const resolveStorageBucketName = async (options) => {
+  const projectName = basename(options.cwd ?? process.cwd());
+  if (options.bucket !== void 0 && options.bucket !== "") {
+    const sanitized = sanitizeBucketName(options.bucket);
+    if (sanitized !== void 0) {
+      return sanitized;
+    }
+    const fallback = deriveBucketName(projectName);
+    options.logger.warn(`add: "${options.bucket}" isn't a valid R2 bucket name (lowercase alphanumeric + hyphens, 3–63 chars) — using "${fallback}".`);
+    return fallback;
+  }
+  if (options.yes === true) {
+    return deriveBucketName(projectName);
+  }
+  return promptBucketName(textPrompt(options), projectName);
+};
+const resolveMailDestination = async (options) => {
+  const warn = (message) => {
+    options.logger.warn(`add: ${message}`);
+  };
+  if (options.mailTo !== void 0 && options.mailTo !== "") {
+    return resolveTypedDestination(options.mailTo, warn);
+  }
+  if (options.yes === true) {
+    return void 0;
+  }
+  return resolveTypedDestination(await textPrompt(options)(MAIL_DESTINATION_PROMPT, { placeholder: "you@yourdomain.com" }), warn);
+};
+const resolveAuthDatabaseName = async (options) => {
+  const projectName = basename(options.cwd ?? process.cwd());
+  if (options.db !== void 0 && options.db !== "") {
+    const sanitized = sanitizeDatabaseName(options.db);
+    if (sanitized !== void 0) {
+      return sanitized;
+    }
+    const fallback = deriveDatabaseName(projectName);
+    options.logger.warn(`add: "${options.db}" isn't a usable D1 database name — using "${fallback}".`);
+    return fallback;
+  }
+  if (options.yes === true) {
+    return deriveDatabaseName(projectName);
+  }
+  return promptDatabaseName(textPrompt(options), projectName);
+};
 const resolveFeatureItems = async (feature, options) => {
   if (feature.kind === "auth") {
     return [await resolveAuthItem(options)];
@@ -49,6 +95,28 @@ const runAddFeature = async (options) => {
     return { code: 1, items: [] };
   }
   const items = await resolveFeatureItems(feature, options);
+  const transforms = [];
+  if (items.includes("storage")) {
+    const bucketName = await resolveStorageBucketName(options);
+    transforms.push((manifest) => withStorageBucketName(manifest, bucketName));
+  }
+  if (items.includes("mail")) {
+    const destination = await resolveMailDestination(options);
+    if (destination !== void 0) {
+      transforms.push((manifest) => withMailDestination(manifest, destination));
+    }
+  }
+  if (items.some((name) => name === "auth" || name.startsWith("auth-"))) {
+    const databaseName = await resolveAuthDatabaseName(options);
+    transforms.push((manifest) => withAuthDatabaseName(manifest, databaseName));
+  }
+  const transformManifest = transforms.length > 0 ? (manifest) => {
+    let result2 = manifest;
+    for (const transform of transforms) {
+      result2 = transform(result2);
+    }
+    return result2;
+  } : void 0;
   const result = await runAddCommand({
     allowUnsafeSource: options.allowUnsafeSource,
     cwd,
@@ -57,22 +125,35 @@ const runAddFeature = async (options) => {
     names: [...items],
     ref: options.ref,
     source: options.source,
+    transformManifest,
     yes: true
   });
   return { code: result.code, items };
 };
 const execute = defineHandler(async ({ argument, cwd, logger, options }) => {
+  const formatError = validateOutputFormat("add", options.format);
+  if (formatError !== void 0) {
+    logger.error(formatError);
+    return { code: 1 };
+  }
+  const effectiveLogger = loggerForFormat(options.format, logger);
   const result = await runAddFeature({
     allowUnsafeSource: options.allowUnsafeSource === true,
+    bucket: options.bucket,
     cwd,
+    db: options.db,
     feature: argument[0],
     from: options.from,
-    logger,
+    logger: effectiveLogger,
+    mailTo: options.mailTo,
     provider: options.provider,
     ref: options.ref,
     source: options.source,
     yes: options.yes === true
   });
+  if (isJsonFormat(options.format)) {
+    printJson({ code: result.code, items: result.items });
+  }
   return { code: result.code };
 });
 

package/dist/packem_chunks/handler10.mjs

@@ -1,22 +1,16 @@
-import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
 import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
-import { runImportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs';
+import { runExportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-D0VOTerB.mjs';
 
-const execute = defineHandler(({ argument, cwd, logger, options }) => {
-  const file = argument[0];
-  if (!file) {
-    logger.error("import requires a file. Usage: lunora import <path> [--table <name>]");
-    return { code: 1 };
-  }
-  return runImportCommand({
-    batchSize: options.batchSize,
-    file,
+const execute = defineHandler(
+  ({ argument, cwd, logger, options }) => runExportCommand({
     logger,
+    out: argument[0] ?? options.out,
     prod: options.prod === true,
-    table: options.table,
+    tables: options.tables,
     token: options.token,
     url: resolveProductionWorkerUrl({ cwd, prod: options.prod === true, url: options.url })
-  });
-});
+  })
+);
 
 export { execute };

package/dist/packem_chunks/handler11.mjs

@@ -1,192 +1,23 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { discoverSchema } from '@lunora/codegen';
-import { readLinkedProject } from '@lunora/config';
-import { parse } from 'jsonc-parser';
-import { Project } from 'ts-morph';
-import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { d as defineHandler } from '../packem_shared/command-lYnl4QyF.mjs';
+import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
+import { runImportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-D0VOTerB.mjs';
 
-const findWranglerFile = (projectRoot) => {
-  for (const candidate of ["wrangler.jsonc", "wrangler.json"]) {
-    const fullPath = join(projectRoot, candidate);
-    if (existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return void 0;
-};
-const stringField = (record, key) => {
-  if (record === null || typeof record !== "object") {
-    return void 0;
-  }
-  const value = record[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-};
-const arrayField = (record, key) => {
-  if (record === null || typeof record !== "object") {
-    return [];
-  }
-  const value = record[key];
-  return Array.isArray(value) ? value : [];
-};
-const summariseWrangler = (raw) => {
-  const durableObjectBindings = arrayField(raw.durable_objects ?? {}, "bindings");
-  const d1 = arrayField(raw, "d1_databases");
-  const vectorize = arrayField(raw, "vectorize");
-  return {
-    bindings: {
-      d1: d1.map((entry) => stringField(entry, "binding") ?? "<unnamed>"),
-      durableObjects: durableObjectBindings.map((entry) => stringField(entry, "name") ?? "<unnamed>"),
-      vectorize: vectorize.map((entry) => stringField(entry, "binding") ?? "<unnamed>")
-    },
-    compatibilityDate: stringField(raw, "compatibility_date"),
-    compatibilityFlags: arrayField(raw, "compatibility_flags").filter((entry) => typeof entry === "string"),
-    main: stringField(raw, "main"),
-    name: stringField(raw, "name")
-  };
-};
-const summariseSchema = (schema) => {
-  return {
-    tables: schema.tables.map((table) => {
-      let shard = "root";
-      if (table.shardMode === "global") {
-        shard = "global";
-      } else if (typeof table.shardMode === "object") {
-        shard = `shardBy(${table.shardMode.field})`;
-      }
-      return {
-        indexes: table.indexes.length,
-        name: table.name,
-        shard
-      };
-    }),
-    vectorIndexes: schema.vectorIndexes.length
-  };
-};
-const collectLunoraPackages = (projectRoot) => {
-  const pkgPath = join(projectRoot, "package.json");
-  if (!existsSync(pkgPath)) {
-    return [];
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-  } catch {
-    return [];
-  }
-  if (pkg === null || typeof pkg !== "object") {
-    return [];
-  }
-  const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
-  const seen = /* @__PURE__ */ new Map();
-  for (const section of sections) {
-    const block = pkg[section];
-    if (block === null || typeof block !== "object") {
-      continue;
-    }
-    for (const [name, version] of Object.entries(block)) {
-      if (!name.startsWith("@lunora/")) {
-        continue;
-      }
-      if (typeof version === "string" && !seen.has(name)) {
-        seen.set(name, version);
-      }
-    }
-  }
-  return [...seen.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([name, version]) => {
-    return { name, version };
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const file = argument[0];
+  if (!file) {
+    logger.error("import requires a file. Usage: lunora import <path> [--table <name>]");
+    return { code: 1 };
+  }
+  return runImportCommand({
+    batchSize: options.batchSize,
+    file,
+    logger,
+    prod: options.prod === true,
+    table: options.table,
+    token: options.token,
+    url: resolveProductionWorkerUrl({ cwd, prod: options.prod === true, url: options.url }),
+    yes: options.yes === true
   });
-};
-const collectInfo = (projectRoot) => {
-  const lunoraPackages = collectLunoraPackages(projectRoot);
-  const wranglerPath = findWranglerFile(projectRoot);
-  let wrangler;
-  if (wranglerPath) {
-    try {
-      wrangler = summariseWrangler(parse(readFileSync(wranglerPath, "utf8")));
-    } catch {
-      wrangler = void 0;
-    }
-  }
-  const schemaPath = join(projectRoot, "lunora", "schema.ts");
-  let schema;
-  let schemaError;
-  if (existsSync(schemaPath)) {
-    try {
-      const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
-      schema = summariseSchema(discoverSchema(project, schemaPath));
-    } catch (error) {
-      schemaError = error instanceof Error ? error.message : String(error);
-    }
-  }
-  return {
-    link: readLinkedProject(projectRoot),
-    lunoraPackages,
-    projectRoot,
-    schema,
-    schemaError,
-    wrangler,
-    wranglerPath
-  };
-};
-const renderText = (snapshot, logger) => {
-  logger.info(`project: ${snapshot.projectRoot}`);
-  logger.info("");
-  logger.info("@lunora/* packages:");
-  if (snapshot.lunoraPackages.length === 0) {
-    logger.info("  (none found in package.json)");
-  } else {
-    for (const pkg of snapshot.lunoraPackages) {
-      logger.info(`  ${pkg.name}@${pkg.version}`);
-    }
-  }
-  logger.info("");
-  if (snapshot.wrangler) {
-    logger.info(`wrangler: ${snapshot.wranglerPath ?? ""}`);
-    logger.info(`  name:               ${snapshot.wrangler.name ?? "<unset>"}`);
-    logger.info(`  main:               ${snapshot.wrangler.main ?? "<unset>"}`);
-    logger.info(`  compatibility_date: ${snapshot.wrangler.compatibilityDate ?? "<unset>"}`);
-    logger.info(`  compatibility_flags: ${snapshot.wrangler.compatibilityFlags.join(", ") || "<none>"}`);
-    logger.info(`  durable objects:    ${snapshot.wrangler.bindings.durableObjects.join(", ") || "<none>"}`);
-    logger.info(`  d1 databases:       ${snapshot.wrangler.bindings.d1.join(", ") || "<none>"}`);
-    logger.info(`  vectorize indexes:  ${snapshot.wrangler.bindings.vectorize.join(", ") || "<none>"}`);
-  } else {
-    logger.info("wrangler: (not found)");
-  }
-  logger.info("");
-  if (snapshot.link) {
-    logger.info(`link: ${snapshot.link.workerName ?? "(unnamed)"} -> ${snapshot.link.workerUrl ?? "<no url>"}`);
-    if (snapshot.link.env !== void 0) {
-      logger.info(`  env: ${snapshot.link.env}`);
-    }
-  } else {
-    logger.info("link: (not linked — run `lunora link --url <https://your-worker>`)");
-  }
-  logger.info("");
-  if (snapshot.schemaError !== void 0) {
-    logger.warn(`schema: parse error — ${snapshot.schemaError}`);
-  } else if (snapshot.schema) {
-    logger.info(`schema: ${String(snapshot.schema.tables.length)} table(s), ${String(snapshot.schema.vectorIndexes)} vector index(es)`);
-    for (const table of snapshot.schema.tables) {
-      logger.info(`  ${table.name}  [${table.shard}, ${String(table.indexes)} index(es)]`);
-    }
-  } else {
-    logger.info("schema: (no lunora/schema.ts)");
-  }
-};
-const runInfoCommand = (options) => {
-  const cwd = options.cwd ?? process.cwd();
-  const snapshot = collectInfo(cwd);
-  if (options.json) {
-    process.stdout.write(`${JSON.stringify(snapshot, void 0, 2)}
-`);
-  } else {
-    renderText(snapshot, options.logger);
-  }
-  return { code: 0, snapshot };
-};
-const execute = defineHandler(
-  ({ cwd, logger, options }) => runInfoCommand({ cwd, json: options.json === true, logger })
-);
+});
 
-export { collectInfo, execute, runInfoCommand };
+export { execute };