devflare 1.0.0-next.21 → 1.0.0-next.23

package/dist/index-p9xq83p7.js

@@ -0,0 +1,147 @@
+import {
+  normalizeSecretsStoreBinding
+} from "./index-f46984zs.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 };

package/dist/index-q15nj71j.js

@@ -0,0 +1,52 @@
+import {
+  findFiles
+} from "./index-qwgr4q7s.js";
+import {
+  resolveConfigPath
+} from "./index-f46984zs.js";
+
+// src/cli/config-path.ts
+import { stat } from "node:fs/promises";
+var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+var SUPPORTED_CONFIG_FILENAMES = CONFIG_FILE_EXTENSIONS.map((extension) => `devflare.config${extension}`);
+function hasKnownConfigExtension(filePath) {
+  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+async function getExistingFilePath(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    return fileStat.isFile() ? filePath : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveConfigCandidatePath(candidatePath) {
+  const candidates = [candidatePath];
+  if (!hasKnownConfigExtension(candidatePath)) {
+    for (const extension of CONFIG_FILE_EXTENSIONS) {
+      candidates.push(`${candidatePath}${extension}`);
+    }
+  }
+  for (const candidate of candidates) {
+    const existingFilePath = await getExistingFilePath(candidate);
+    if (existingFilePath) {
+      return existingFilePath;
+    }
+  }
+  return await resolveConfigPath(candidatePath) ?? null;
+}
+async function findConfigPathsUnderDirectory(rootDir) {
+  const matches = await findFiles([
+    ...SUPPORTED_CONFIG_FILENAMES,
+    ...SUPPORTED_CONFIG_FILENAMES.map((filename) => `**/${filename}`)
+  ], {
+    cwd: rootDir,
+    absolute: true
+  });
+  return [...new Set(matches)].sort((left, right) => left.localeCompare(right));
+}
+function formatSupportedConfigFilenames() {
+  return SUPPORTED_CONFIG_FILENAMES.join(", ");
+}
+
+export { resolveConfigCandidatePath, findConfigPathsUnderDirectory, formatSupportedConfigFilenames };