devflare 1.0.0-next.22 → 1.0.0-next.24

package/dist/index-cwjjdtgn.js

@@ -0,0 +1,74 @@
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./index-f46984zs.js";
+import {
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  getWorkspaceAccountId
+} from "./index-1d4jg11n.js";
+
+// src/cli/command-utils.ts
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function resolveNamedSelection(options) {
+  if (options.explicitValue) {
+    return {
+      value: options.explicitValue,
+      source: "option"
+    };
+  }
+  if (options.fallbackValue) {
+    return {
+      value: options.fallbackValue,
+      source: "arg"
+    };
+  }
+  if (options.configuredValue) {
+    return {
+      value: options.configuredValue,
+      source: "config"
+    };
+  }
+  return {
+    value: undefined,
+    source: "none"
+  };
+}
+async function getConfiguredAccountId(cwd) {
+  const workspaceAccountId = getWorkspaceAccountId();
+  if (workspaceAccountId) {
+    return workspaceAccountId;
+  }
+  const envAccountId = process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+  if (envAccountId) {
+    return envAccountId;
+  }
+  const configPath = await resolveConfigPath(cwd);
+  if (!configPath) {
+    return;
+  }
+  try {
+    const config = await loadConfig({ cwd });
+    return config.accountId;
+  } catch {
+    return;
+  }
+}
+async function resolveCloudflareAccountId(options) {
+  if (options.explicitAccountId) {
+    return options.explicitAccountId;
+  }
+  if (options.configuredAccountId) {
+    return options.configuredAccountId;
+  }
+  const primaryAccount = await getPrimaryAccount(options.apiOptions);
+  if (!primaryAccount) {
+    return;
+  }
+  const effective = await getEffectiveAccountId(primaryAccount.id);
+  return effective.accountId;
+}
+
+export { asOptionalString, resolveNamedSelection, getConfiguredAccountId, resolveCloudflareAccountId };

package/dist/index-d00njc1f.js

@@ -0,0 +1,147 @@
+import {
+  normalizeSecretsStoreBinding
+} from "./index-cna43592.js";
+
+// src/secrets/local-secrets.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var LOCAL_SECRETS_PATH = join(".devflare", "secrets.local.json");
+var LOCAL_SECRET_WRAPPED_BINDING_SCRIPT = `
+class LocalSecretsStoreSecret {
+	constructor(env) {
+		this.value = env.value
+	}
+
+	async get() {
+		return this.value
+	}
+}
+
+export default function makeBinding(env) {
+	return new LocalSecretsStoreSecret(env)
+}
+`;
+function createEmptyLocalSecretsFile() {
+  return {
+    version: 1,
+    stores: {}
+  };
+}
+function getLocalSecretsFilePath(cwd) {
+  return join(cwd, LOCAL_SECRETS_PATH);
+}
+function parseLocalSecretsFile(raw) {
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 1 || !parsed.stores || typeof parsed.stores !== "object") {
+    return createEmptyLocalSecretsFile();
+  }
+  return {
+    version: 1,
+    stores: parsed.stores
+  };
+}
+function readLocalSecretsFile(cwd) {
+  const filePath = getLocalSecretsFilePath(cwd);
+  if (!existsSync(filePath)) {
+    return createEmptyLocalSecretsFile();
+  }
+  return parseLocalSecretsFile(readFileSync(filePath, "utf8"));
+}
+function writeLocalSecretsFile(cwd, file) {
+  const filePath = getLocalSecretsFilePath(cwd);
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(file, null, "\t")}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function writeLocalSecret({ cwd, storeId, name, value }) {
+  const file = readLocalSecretsFile(cwd);
+  file.stores[storeId] ??= {};
+  file.stores[storeId][name] = {
+    value,
+    updatedAt: new Date().toISOString()
+  };
+  writeLocalSecretsFile(cwd, file);
+}
+function readLocalSecret({ cwd, storeId, name }) {
+  return readLocalSecretsFile(cwd).stores[storeId]?.[name]?.value;
+}
+function deleteLocalSecret({ cwd, storeId, name }) {
+  const file = readLocalSecretsFile(cwd);
+  const store = file.stores[storeId];
+  if (!store || !(name in store)) {
+    return false;
+  }
+  delete store[name];
+  if (Object.keys(store).length === 0) {
+    delete file.stores[storeId];
+  }
+  writeLocalSecretsFile(cwd, file);
+  return true;
+}
+function listLocalSecrets({ cwd, storeId }) {
+  const file = readLocalSecretsFile(cwd);
+  const stores = storeId ? { [storeId]: file.stores[storeId] ?? {} } : file.stores;
+  return Object.entries(stores).flatMap(([currentStoreId, secrets]) => Object.entries(secrets).map(([name, secret]) => ({
+    storeId: currentStoreId,
+    name,
+    hasValue: typeof secret.value === "string",
+    updatedAt: secret.updatedAt
+  })));
+}
+function resolveLocalSecretValuesForBindings(config, cwd) {
+  const values = {};
+  for (const [bindingName, binding] of Object.entries(config.bindings?.secretsStore ?? {})) {
+    const normalized = normalizeSecretsStoreBinding(binding, config.secretsStoreId, bindingName);
+    const value = readLocalSecret({
+      cwd,
+      storeId: normalized.storeId,
+      name: normalized.secretName
+    });
+    if (value !== undefined) {
+      values[bindingName] = value;
+    }
+  }
+  return values;
+}
+function toLocalSecretWorkerName(bindingName, index) {
+  const slug = bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "secret";
+  return `devflare-local-secret-${index}-${slug}`;
+}
+function buildLocalSecretWrappedBindingConfig(config, cwd) {
+  const values = resolveLocalSecretValuesForBindings(config, cwd);
+  const entries = Object.entries(values);
+  return {
+    localBindingNames: entries.map(([bindingName]) => bindingName),
+    wrappedBindings: Object.fromEntries(entries.map(([bindingName, value], index) => {
+      const scriptName = toLocalSecretWorkerName(bindingName, index);
+      return [
+        bindingName,
+        {
+          scriptName,
+          bindings: { value }
+        }
+      ];
+    })),
+    workers: entries.map(([bindingName], index) => ({
+      name: toLocalSecretWorkerName(bindingName, index),
+      modules: true,
+      script: LOCAL_SECRET_WRAPPED_BINDING_SCRIPT
+    }))
+  };
+}
+function buildLocalSecretNodeBindings(config, cwd) {
+  const values = resolveLocalSecretValuesForBindings(config, cwd);
+  return Object.fromEntries(Object.entries(values).map(([bindingName, value]) => [
+    bindingName,
+    {
+      async get() {
+        return value;
+      }
+    }
+  ]));
+}
+
+export { writeLocalSecret, deleteLocalSecret, listLocalSecrets, resolveLocalSecretValuesForBindings, buildLocalSecretWrappedBindingConfig, buildLocalSecretNodeBindings };