@base44/functions-compiler 0.1.4 → 0.1.6

package/lib/src/private-data-sources/build-http.ts

@@ -1,51 +0,0 @@
-import { resolveHttpPrivateDataSourceUrl } from "./http-url";
-import {
-  currentPrivateDataSource,
-  privateDataSourceBinding,
-} from "./manifest";
-import type { FetchPrivateDataSourceBinding, PrivateDataSourceManifestEntry } from "./types";
-
-// Internal, NOT a public virtual module: app code cannot import this builder to
-// hand-forge a manifest entry. The only public entrypoints — http()/elasticsearch()
-// — resolve their entry from the immutable runtime manifest via lookupPrivateDataSource.
-
-function hasFetch(binding: unknown): binding is FetchPrivateDataSourceBinding {
-  return (
-    binding !== null &&
-    typeof binding === "object" &&
-    typeof (binding as { fetch?: unknown }).fetch === "function"
-  );
-}
-
-export function buildHttpPrivateDataSource(entry: PrivateDataSourceManifestEntry) {
-  return Object.freeze({
-    name: entry.name,
-    type: entry.type,
-    get bindingName() {
-      return currentPrivateDataSource(entry).bindingName;
-    },
-    fetch(resource: RequestInfo | URL, init?: RequestInit) {
-      const current = currentPrivateDataSource(entry);
-      const binding = privateDataSourceBinding(current);
-      if (!hasFetch(binding)) {
-        throw new Error(
-          `Private data source "${current.name}" does not expose fetch()`,
-        );
-      }
-      return binding.fetch(
-        resolveHttpPrivateDataSourceUrl(current, resource),
-        init,
-      );
-    },
-    // Fixed services expose the raw binding (Cloudflare pins their single
-    // target). Deferred Actor handles decide this from the request manifest,
-    // after their request environment exists.
-    get binding() {
-      const current = currentPrivateDataSource(entry);
-      return current.bindingName !== undefined
-        && current.networkScope !== "network"
-        ? privateDataSourceBinding(current)
-        : undefined;
-    },
-  });
-}

package/lib/src/private-data-sources/elasticsearch.ts

@@ -1,8 +0,0 @@
-import { buildHttpPrivateDataSource } from "./build-http";
-import { privateDataSourceReference } from "./manifest";
-
-export function elasticsearch(name: unknown) {
-  return buildHttpPrivateDataSource(
-    privateDataSourceReference(name, "elasticsearch"),
-  );
-}

package/lib/src/private-data-sources/http-url.ts

@@ -1,23 +0,0 @@
-import type { PrivateDataSourceManifestEntry } from "./types";
-
-const FALLBACK_BASE_URL = "http://private-data-source.local";
-
-/**
- * Resolve a fetch target for an HTTP private data source. Relative paths resolve
- * against the source's base URL; absolute URLs pass through. There is no host
- * allowlist: for a fixed VPC service Cloudflare pins the single target, and for a
- * network binding the reachable set is the customer's tunnel scope — the app can
- * fetch any host behind it (e.g. Trino router + cluster nextUri hosts).
- */
-export function resolveHttpPrivateDataSourceUrl(
-  entry: PrivateDataSourceManifestEntry,
-  resource: RequestInfo | URL,
-): RequestInfo | URL {
-  if (resource instanceof Request) return resource;
-  const raw = resource instanceof URL ? resource.toString() : String(resource);
-  try {
-    return new URL(raw).toString();
-  } catch {
-    return new URL(raw || "/", entry.baseUrl || FALLBACK_BASE_URL).toString();
-  }
-}

package/lib/src/private-data-sources/http.ts

@@ -1,6 +0,0 @@
-import { buildHttpPrivateDataSource } from "./build-http";
-import { privateDataSourceReference } from "./manifest";
-
-export function http(name: unknown) {
-  return buildHttpPrivateDataSource(privateDataSourceReference(name, "http"));
-}

package/lib/src/private-data-sources/hyperdrive.ts

@@ -1,48 +0,0 @@
-import {
-  currentPrivateDataSource,
-  privateDataSourceReference,
-  privateDataSourceBinding,
-} from "./manifest";
-import type { PrivateDataSourceManifestEntry } from "./types";
-
-export function buildHyperdrivePrivateDataSource(entry: PrivateDataSourceManifestEntry) {
-  const binding = () =>
-    privateDataSourceBinding(entry) as Record<string, unknown>;
-  return Object.freeze({
-    name: entry.name,
-    type: entry.type,
-    get bindingName() {
-      return currentPrivateDataSource(entry).bindingName;
-    },
-    get connectionString() {
-      return binding().connectionString;
-    },
-    get host() {
-      return binding().host;
-    },
-    get port() {
-      return binding().port;
-    },
-    get user() {
-      return binding().user;
-    },
-    get username() {
-      return binding().user;
-    },
-    get password() {
-      return binding().password;
-    },
-    get database() {
-      return binding().database;
-    },
-    get binding() {
-      return binding();
-    },
-  });
-}
-
-export function hyperdrive(name: unknown) {
-  return buildHyperdrivePrivateDataSource(
-    privateDataSourceReference(name, "hyperdrive"),
-  );
-}

package/lib/src/private-data-sources/ioredis-adapter.ts

@@ -1,229 +0,0 @@
-import { Buffer } from "node:buffer";
-import { EventEmitter } from "node:events";
-
-import { isCloudflareTcpSocket } from "./tcp";
-
-type IoredisErrorEmitter = (type: string, err: Error) => void;
-
-interface IoredisNetStream extends EventEmitter {
-  connecting: boolean;
-  destroyed: boolean;
-  readable: boolean;
-  writable: boolean;
-  remoteAddress?: string;
-  remotePort?: number;
-  _writableState: { ended: boolean };
-  write(data: string | Uint8Array, callback?: (err?: Error | null) => void): boolean;
-  end(data?: string | Uint8Array | (() => void), callback?: () => void): IoredisNetStream;
-  destroy(error?: Error): IoredisNetStream;
-  setNoDelay(noDelay?: boolean): IoredisNetStream;
-  setKeepAlive(enable?: boolean, initialDelay?: number): IoredisNetStream;
-  setTimeout(timeout: number, callback?: () => void): IoredisNetStream;
-  resume(): IoredisNetStream;
-  pause(): IoredisNetStream;
-}
-
-function exactNodeBuffer(value: Uint8Array): Buffer {
-  const bytes = new Uint8Array(value.byteLength);
-  bytes.set(value);
-  return Buffer.from(bytes.buffer);
-}
-
-function buildIoredisNetStream(
-  socket: unknown,
-  errorEmitter?: IoredisErrorEmitter,
-): IoredisNetStream {
-  if (!isCloudflareTcpSocket(socket)) {
-    throw new Error("Redis private data source did not return a readable/writable TCP socket");
-  }
-  const cloudflareSocket = socket;
-
-  const encoder = new TextEncoder();
-  const stream = new EventEmitter() as IoredisNetStream;
-  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
-  let writer: WritableStreamDefaultWriter<Uint8Array> | null = null;
-  let readStarted = false;
-  let connectEmitted = false;
-  let closed = false;
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-  let writeChain = Promise.resolve();
-
-  function setClosed() {
-    if (closed) return;
-    closed = true;
-    stream.destroyed = true;
-    stream.readable = false;
-    stream.writable = false;
-    stream._writableState.ended = true;
-    if (timeout) {
-      clearTimeout(timeout);
-      timeout = null;
-    }
-    try {
-      reader?.releaseLock();
-    } catch {
-      // Ignore release errors when the stream is already closed.
-    }
-    reader = null;
-    try {
-      writer?.releaseLock();
-    } catch {
-      // Ignore release errors when the stream is already closed.
-    }
-    writer = null;
-    stream.emit("close");
-  }
-
-  function emitError(error: unknown) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    errorEmitter?.("error", err);
-    stream.emit("error", err);
-  }
-
-  function markConnected() {
-    if (closed || connectEmitted) return;
-    connectEmitted = true;
-    stream.connecting = false;
-    stream.emit("connect");
-  }
-
-  async function readLoop() {
-    const activeReader = reader ?? cloudflareSocket.readable.getReader();
-    reader = activeReader;
-    try {
-      while (!closed) {
-        const { value, done } = await activeReader.read();
-        if (done) break;
-        if (value) stream.emit("data", exactNodeBuffer(value));
-      }
-      setClosed();
-    } catch (error) {
-      if (!closed) {
-        emitError(error);
-        setClosed();
-      }
-    }
-  }
-
-  function writeBytes(bytes: Uint8Array) {
-    if (closed) return Promise.reject(new Error("Redis connection is closed"));
-    const activeWriter = writer ?? cloudflareSocket.writable.getWriter();
-    writer = activeWriter;
-    return activeWriter.write(bytes);
-  }
-
-  stream.connecting = true;
-  stream.destroyed = false;
-  stream.readable = true;
-  stream.writable = true;
-  stream._writableState = { ended: false };
-  stream.write = (data, callback) => {
-    const bytes = typeof data === "string" ? encoder.encode(data) : data;
-    writeChain = writeChain
-      .then(() => writeBytes(bytes))
-      .then(
-        () => callback?.(),
-        (error) => {
-          const err = error instanceof Error ? error : new Error(String(error));
-          callback?.(err);
-          emitError(err);
-        },
-      );
-    return true;
-  };
-  stream.end = (data?: string | Uint8Array | (() => void), callback?: () => void) => {
-    const done = typeof data === "function" ? data : callback;
-    if (typeof data === "string" || data instanceof Uint8Array) {
-      stream.write(data);
-    }
-    writeChain
-      .finally(() => {
-        done?.();
-        try {
-          cloudflareSocket.close?.();
-        } finally {
-          setClosed();
-        }
-      })
-      .catch(() => {});
-    return stream;
-  };
-  stream.destroy = (error?: Error) => {
-    if (error) emitError(error);
-    try {
-      cloudflareSocket.close?.();
-    } finally {
-      setClosed();
-    }
-    return stream;
-  };
-  stream.setNoDelay = () => stream;
-  stream.setKeepAlive = () => stream;
-  stream.setTimeout = (duration, callback) => {
-    if (timeout) clearTimeout(timeout);
-    timeout = null;
-    if (duration > 0) {
-      timeout = setTimeout(() => {
-        callback?.();
-        stream.emit("timeout");
-      }, duration);
-    }
-    return stream;
-  };
-  stream.resume = () => {
-    if (!readStarted) {
-      readStarted = true;
-      readLoop();
-    }
-    return stream;
-  };
-  stream.pause = () => stream;
-
-  if (cloudflareSocket.opened) {
-    cloudflareSocket.opened.then(markConnected, (error) => {
-      emitError(error);
-      stream.destroy(error instanceof Error ? error : new Error(String(error)));
-    });
-  } else {
-    queueMicrotask(markConnected);
-  }
-  cloudflareSocket.closed?.finally(setClosed).catch(() => {});
-  return stream;
-}
-
-export function buildIoredisConnectorFactory(connect: () => unknown) {
-  return class Base44IoredisConnector {
-    firstError?: Error;
-    private stream?: IoredisNetStream;
-    private disconnectTimeout: number;
-
-    constructor(options?: { disconnectTimeout?: number }) {
-      this.disconnectTimeout =
-        typeof options?.disconnectTimeout === "number" ? options.disconnectTimeout : 2000;
-    }
-
-    check() {
-      return true;
-    }
-
-    connect(errorEmitter?: IoredisErrorEmitter) {
-      return Promise.resolve(connect()).then((socket) => {
-        try {
-          this.stream = buildIoredisNetStream(socket, errorEmitter);
-          return this.stream;
-        } catch (error) {
-          this.firstError = error instanceof Error ? error : new Error(String(error));
-          throw this.firstError;
-        }
-      });
-    }
-
-    disconnect() {
-      const stream = this.stream;
-      if (!stream || stream.destroyed) return;
-      const timeout = setTimeout(() => stream.destroy(), this.disconnectTimeout);
-      stream.once("close", () => clearTimeout(timeout));
-      stream.end();
-    }
-  };
-}

package/lib/src/private-data-sources/manifest.ts

@@ -1,150 +0,0 @@
-import {
-  currentWorkerRuntimeContext,
-  workerEnvironment,
-} from "./runtime-environment";
-import { getRuntimeManifest } from "./runtime-manifest-store";
-import type { PrivateDataSourceManifestEntry } from "./types";
-
-const PRIVATE_DATA_SOURCES_MANIFEST_ENV = "BASE44_PRIVATE_DATA_SOURCES";
-
-function readStringVar(key: string): string | undefined {
-  const value = workerEnvironment()[key];
-  return typeof value === "string" ? value : undefined;
-}
-
-// Pin a HANDSHAKE-DELIVERED manifest to the deployed binding set: it is resolved
-// fresh per activation, but the script's Hyperdrive/VPC bindings are frozen at
-// upload — a source added/renamed since then must not surface an entry whose
-// binding this script does not have (its lookup would pass and then fail deeper
-// at privateDataSourceBinding). A manifest that exists as a Worker binding was
-// frozen together with the live bindings, so it is served unfiltered.
-function entryBindingIsDeployed(entry: PrivateDataSourceManifestEntry): boolean {
-  return typeof entry.bindingName === "string" && workerEnvironment()[entry.bindingName] !== undefined;
-}
-
-function parsePrivateDataSourceManifest(): PrivateDataSourceManifestEntry[] {
-  // Runtime-secrets bundles receive the manifest through the private, single-
-  // instance store the activation shim writes (see runtime-manifest-store) — NOT
-  // the Worker binding, process.env, or any user-reachable global. Old mode has
-  // no runtime manifest and falls through to the immutable Worker binding.
-  const runtimeRaw = getRuntimeManifest();
-  const fromHandshake = runtimeRaw !== undefined;
-  const raw = fromHandshake ? runtimeRaw : readStringVar(PRIVATE_DATA_SOURCES_MANIFEST_ENV);
-  if (!raw) return [];
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return [];
-  }
-  const entries = Array.isArray(parsed)
-    ? parsed.filter(
-        (entry): entry is PrivateDataSourceManifestEntry =>
-          entry !== null && typeof entry === "object",
-      )
-    : [];
-  return fromHandshake ? entries.filter(entryBindingIsDeployed) : entries;
-}
-
-export function normalizePrivateDataSourceKey(value: unknown): string {
-  return String(value || "")
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "_")
-    .replace(/^_+|_+$/g, "");
-}
-
-export function privateDataSourceReference(
-  requestedName: unknown,
-  expectedType: string,
-): PrivateDataSourceManifestEntry {
-  if (currentWorkerRuntimeContext()) {
-    return lookupPrivateDataSource(requestedName, expectedType);
-  }
-  return {
-    name: String(requestedName || ""),
-    type: expectedType,
-  };
-}
-
-function privateDataSourceMatchRank(
-  entry: PrivateDataSourceManifestEntry,
-  requestedName: unknown,
-): number | null {
-  const requested = String(requestedName || "");
-  const normalizedRequested = normalizePrivateDataSourceKey(requested);
-  const candidates = [
-    { value: entry.name, rank: 0 },
-    { value: entry.bindingName, rank: 1 },
-    { value: entry.name, rank: 2, normalized: true },
-    { value: entry.bindingName, rank: 3, normalized: true },
-  ];
-  let bestRank: number | null = null;
-  for (const candidate of candidates) {
-    if (typeof candidate.value !== "string") continue;
-    const matches = candidate.normalized
-      ? normalizePrivateDataSourceKey(candidate.value) === normalizedRequested
-      : candidate.value === requested;
-    if (matches && (bestRank === null || candidate.rank < bestRank)) {
-      bestRank = candidate.rank;
-    }
-  }
-  return bestRank;
-}
-
-function privateDataSourceMatchesExpectedType(
-  entry: PrivateDataSourceManifestEntry,
-  expectedType: string,
-): boolean {
-  return entry.type === expectedType || (expectedType === "hyperdrive" && entry.bindingKind === "hyperdrive");
-}
-
-export function lookupPrivateDataSource(
-  requestedName: unknown,
-  expectedType?: string,
-): PrivateDataSourceManifestEntry {
-  const matches = parsePrivateDataSourceManifest()
-    .map((entry) => ({ entry, rank: privateDataSourceMatchRank(entry, requestedName) }))
-    .filter((match): match is { entry: PrivateDataSourceManifestEntry; rank: number } => match.rank !== null)
-    .sort((a, b) => a.rank - b.rank);
-  if (matches.length === 0) {
-    throw new Error(`Private data source "${requestedName}" is not bound to this backend function`);
-  }
-
-  const typeMatches = expectedType
-    ? matches.filter((candidate) => privateDataSourceMatchesExpectedType(candidate.entry, expectedType))
-    : matches;
-  if (typeMatches.length === 0) {
-    throw new Error(`Private data source "${requestedName}" is not a ${expectedType} data source`);
-  }
-
-  const bestRank = typeMatches[0].rank;
-  const bestMatches = typeMatches.filter((candidate) => candidate.rank === bestRank);
-  if (bestMatches.length > 1) {
-    const kind = expectedType ? ` ${expectedType}` : "";
-    throw new Error(
-      `Private data source "${requestedName}" is ambiguous: ${bestMatches.length}${kind} data sources match this name`,
-    );
-  }
-  return bestMatches[0].entry;
-}
-
-export function privateDataSourceBinding(entry: PrivateDataSourceManifestEntry): unknown {
-  const current = lookupPrivateDataSource(entry.name, entry.type);
-  if (!current.bindingName) {
-    throw new Error(`Private data source "${current.name}" has no Worker binding name`);
-  }
-  const binding = workerEnvironment()[current.bindingName];
-  if (!binding) {
-    throw new Error(
-      `Private data source binding "${current.bindingName}" is missing from the Worker environment`,
-    );
-  }
-  return binding;
-}
-
-export function currentPrivateDataSource(
-  entry: PrivateDataSourceManifestEntry,
-): PrivateDataSourceManifestEntry {
-  return lookupPrivateDataSource(entry.name, entry.type);
-}

package/lib/src/private-data-sources/mariadb.ts

@@ -1,8 +0,0 @@
-import { buildHyperdrivePrivateDataSource } from "./hyperdrive";
-import { privateDataSourceReference } from "./manifest";
-
-export function mariadb(name: unknown) {
-  return buildHyperdrivePrivateDataSource(
-    privateDataSourceReference(name, "mariadb"),
-  );
-}

package/lib/src/private-data-sources/mongodb.ts

@@ -1,70 +0,0 @@
-import {
-  currentPrivateDataSource,
-  normalizePrivateDataSourceKey,
-  privateDataSourceReference,
-} from "./manifest";
-import { buildTcpPrivateDataSource } from "./tcp";
-import { installPrivateNodeNetAdapter, registerPrivateNodeNetRoute } from "./node-net-adapter";
-import type { PrivateDataSourceManifestEntry } from "./types";
-
-function encodeMongoConnectionPart(value: unknown): string {
-  return encodeURIComponent(String(value ?? ""));
-}
-
-function buildMongoConnectionString(entry: PrivateDataSourceManifestEntry, hostname: string): string {
-  const username = entry.username ? encodeMongoConnectionPart(entry.username) : "";
-  const password = entry.password ? encodeMongoConnectionPart(entry.password) : "";
-  const auth = username ? `${username}${password ? `:${password}` : ""}@` : "";
-  const database = entry.database ? `/${encodeMongoConnectionPart(entry.database)}` : "";
-  const port = typeof entry.port === "number" ? entry.port : 27017;
-  return `mongodb://${auth}${hostname}:${port}${database}?directConnection=true`;
-}
-
-export function mongodb(name: unknown) {
-  installPrivateNodeNetAdapter();
-  const entry = privateDataSourceReference(name, "mongodb");
-  const source = buildTcpPrivateDataSource(entry) as ReturnType<typeof buildTcpPrivateDataSource> & {
-    connect: (options?: unknown) => unknown;
-  };
-  const driverHostname = `base44-private-${normalizePrivateDataSourceKey(
-    entry.bindingName || entry.name || "mongodb",
-  )}`;
-
-  function registerRoute() {
-    const current = currentPrivateDataSource(entry);
-    const port = typeof current.port === "number" ? current.port : 27017;
-    const label = `MongoDB private data source "${current.name || current.bindingName || driverHostname}"`;
-    registerPrivateNodeNetRoute(driverHostname, port, {
-      label,
-      connect: () => source.connect(),
-    });
-  }
-
-  const extension = {
-    driverHost: driverHostname,
-    get connectionString() {
-      const current = currentPrivateDataSource(entry);
-      registerRoute();
-      return buildMongoConnectionString(current, driverHostname);
-    },
-    get uri() {
-      const current = currentPrivateDataSource(entry);
-      registerRoute();
-      return buildMongoConnectionString(current, driverHostname);
-    },
-    mongoClientOptions(options?: Record<string, unknown>) {
-      registerRoute();
-      return Object.freeze({
-        directConnection: true,
-        serverSelectionTimeoutMS: 5000,
-        ...options,
-      });
-    },
-  };
-  return Object.freeze(
-    Object.defineProperties(
-      extension,
-      Object.getOwnPropertyDescriptors(source),
-    ) as typeof source & typeof extension,
-  );
-}

package/lib/src/private-data-sources/mysql.ts

@@ -1,8 +0,0 @@
-import { buildHyperdrivePrivateDataSource } from "./hyperdrive";
-import { privateDataSourceReference } from "./manifest";
-
-export function mysql(name: unknown) {
-  return buildHyperdrivePrivateDataSource(
-    privateDataSourceReference(name, "mysql"),
-  );
-}