devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index-dm9q84c7.js

@@ -0,0 +1,360 @@
+// src/shims/local-media-bindings.ts
+function emptyNodeStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function normalizeNodeContentType(value, fallback) {
+  if (!value)
+    return fallback;
+  if (value.includes("/"))
+    return value;
+  if (value === "jpg" || value === "jpeg")
+    return "image/jpeg";
+  if (value === "png")
+    return "image/png";
+  if (value === "webp")
+    return "image/webp";
+  if (value === "avif")
+    return "image/avif";
+  if (value === "mp4")
+    return "video/mp4";
+  return value;
+}
+async function readNodeBytes(stream) {
+  const buffer = await new Response(stream ?? emptyNodeStream()).arrayBuffer();
+  return new Uint8Array(buffer);
+}
+function streamFromNodeBytes(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return new Response(copy).body ?? emptyNodeStream();
+}
+function createUnsupportedHostedImagesBinding() {
+  const unsupported = () => {
+    throw new Error("Devflare local Images hosted API is not implemented. Use transform/info APIs locally, or connect to Cloudflare for hosted image storage.");
+  };
+  return {
+    image(_imageId) {
+      return {
+        details: unsupported,
+        bytes: unsupported,
+        update: unsupported,
+        delete: unsupported
+      };
+    },
+    upload: unsupported,
+    list: unsupported
+  };
+}
+function createNodeImageResult(bytes, contentType) {
+  return {
+    response() {
+      return new Response(streamFromNodeBytes(bytes), {
+        headers: { "Content-Type": contentType }
+      });
+    },
+    contentType() {
+      return contentType;
+    },
+    image() {
+      return streamFromNodeBytes(bytes);
+    }
+  };
+}
+function createNodeImageTransformer(bytesPromise) {
+  const transformer = {
+    transform(_transform) {
+      return transformer;
+    },
+    draw(_image, _options) {
+      return transformer;
+    },
+    async output(options) {
+      return createNodeImageResult(await bytesPromise, normalizeNodeContentType(options?.format, "image/png"));
+    }
+  };
+  return transformer;
+}
+function createLocalImagesBinding() {
+  return {
+    async info(stream) {
+      const bytes = await readNodeBytes(stream);
+      return {
+        format: "image/png",
+        fileSize: bytes.byteLength,
+        width: 1,
+        height: 1
+      };
+    },
+    input(stream) {
+      return createNodeImageTransformer(readNodeBytes(stream));
+    },
+    hosted: createUnsupportedHostedImagesBinding()
+  };
+}
+function createNodeMediaResult(bytesPromise, contentType) {
+  return {
+    async media() {
+      return streamFromNodeBytes(await bytesPromise);
+    },
+    async response() {
+      return new Response(streamFromNodeBytes(await bytesPromise), {
+        headers: { "Content-Type": contentType }
+      });
+    },
+    async contentType() {
+      return contentType;
+    }
+  };
+}
+function createNodeMediaTransformer(bytesPromise) {
+  const output = (options = {}) => createNodeMediaResult(bytesPromise, normalizeNodeContentType(options.format, "video/mp4"));
+  return {
+    transform(_transform) {
+      return {
+        output(options) {
+          return output(options);
+        }
+      };
+    },
+    output(options) {
+      return output(options);
+    }
+  };
+}
+function createLocalMediaBinding() {
+  return {
+    input(stream) {
+      return createNodeMediaTransformer(readNodeBytes(stream));
+    }
+  };
+}
+var LOCAL_MEDIA_BINDING_SCRIPT = `
+import { RpcTarget, WorkerEntrypoint } from 'cloudflare:workers'
+
+function emptyStream() {
+	return new ReadableStream({
+		start(controller) {
+			controller.close()
+		}
+	})
+}
+
+function normalizeContentType(value, fallback) {
+	if (typeof value !== 'string' || value.length === 0) return fallback
+	if (value.includes('/')) return value
+	if (value === 'jpg') return 'image/jpeg'
+	if (value === 'jpeg') return 'image/jpeg'
+	if (value === 'png') return 'image/png'
+	if (value === 'webp') return 'image/webp'
+	if (value === 'avif') return 'image/avif'
+	if (value === 'mp4') return 'video/mp4'
+	return value
+}
+
+async function readBytes(stream) {
+	return await new Response(stream || emptyStream()).arrayBuffer()
+}
+
+function streamFromBytes(bytes) {
+	return new Response(bytes.slice(0)).body || emptyStream()
+}
+
+function createBodyReader(bytes) {
+	return function takeBody() {
+		return streamFromBytes(bytes)
+	}
+}
+
+class LocalImageResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	contentType() {
+		return this.contentTypeValue
+	}
+
+	image() {
+		return this.takeBody()
+	}
+}
+
+class LocalImageTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return this
+	}
+
+	draw() {
+		return this
+	}
+
+	async output(options = {}) {
+		return new LocalImageResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'image/png')
+		)
+	}
+}
+
+function createHostedImagesBinding() {
+	const unsupported = () => {
+		throw new Error('Devflare local Images hosted API is not implemented. Use the transform/info APIs locally, or connect to Cloudflare for hosted image storage.')
+	}
+	return {
+		image() {
+			return {
+				details: unsupported,
+				bytes: unsupported,
+				update: unsupported,
+				delete: unsupported
+			}
+		},
+		upload: unsupported,
+		list: unsupported
+	}
+}
+
+export class LocalImagesBinding extends WorkerEntrypoint {
+	async info(stream) {
+		const bytes = await readBytes(stream)
+		return {
+			format: 'image/png',
+			fileSize: bytes.byteLength,
+			width: 1,
+			height: 1
+		}
+	}
+
+	async input(stream) {
+		return new LocalImageTransformer(await readBytes(stream))
+	}
+
+	get hosted() {
+		return createHostedImagesBinding()
+	}
+}
+
+class LocalMediaResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	async media() {
+		return this.takeBody()
+	}
+
+	async response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	async contentType() {
+		return this.contentTypeValue
+	}
+}
+
+class LocalMediaTransformationGenerator extends RpcTarget {
+	constructor(takeBody) {
+		super()
+		this.takeBody = takeBody
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+class LocalMediaTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return new LocalMediaTransformationGenerator(this.takeBody)
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+export class LocalMediaBinding extends WorkerEntrypoint {
+	async input(stream) {
+		return new LocalMediaTransformer(await readBytes(stream))
+	}
+}
+
+export default {
+	fetch() {
+		return new Response('Devflare local Images/Media binding')
+	}
+}
+`;
+function toLocalShimWorkerName(kind, bindingName, index) {
+  const slug = bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || kind;
+  return `devflare-local-${kind}-${index}-${slug}`;
+}
+function getEntrypoint(kind) {
+  return kind === "images" ? "LocalImagesBinding" : "LocalMediaBinding";
+}
+function buildLocalBindingShimServiceConfig(config) {
+  const entries = [
+    ...Object.keys(config.bindings?.images ?? {}).map((bindingName) => ({
+      bindingName,
+      kind: "images"
+    })),
+    ...Object.keys(config.bindings?.media ?? {}).map((bindingName) => ({
+      bindingName,
+      kind: "media"
+    }))
+  ];
+  return {
+    localBindingNames: entries.map((entry) => entry.bindingName),
+    serviceBindings: Object.fromEntries(entries.map((entry, index) => {
+      const workerName = toLocalShimWorkerName(entry.kind, entry.bindingName, index);
+      return [
+        entry.bindingName,
+        {
+          name: workerName,
+          entrypoint: getEntrypoint(entry.kind)
+        }
+      ];
+    })),
+    workers: entries.map((entry, index) => ({
+      name: toLocalShimWorkerName(entry.kind, entry.bindingName, index),
+      modules: true,
+      script: LOCAL_MEDIA_BINDING_SCRIPT,
+      compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+      ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
+    }))
+  };
+}
+
+export { createLocalImagesBinding, createLocalMediaBinding, buildLocalBindingShimServiceConfig };

package/dist/index-fcmj6641.js

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