@base44-preview/vite-plugin 1.0.48-pr.138.622eb14 → 1.0.48-pr.142.9fcc12e

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

@@ -0,0 +1,23 @@
+import type { PrivateDataSourceManifestEntry } from "./types.js";
+
+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/src/private-data-sources/http.ts

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

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

@@ -0,0 +1,48 @@
+import {
+  currentPrivateDataSource,
+  privateDataSourceReference,
+  privateDataSourceBinding,
+} from "./manifest.js";
+import type { PrivateDataSourceManifestEntry } from "./types.js";
+
+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/src/private-data-sources/ioredis-adapter.ts

@@ -0,0 +1,229 @@
+import { Buffer } from "node:buffer";
+import { EventEmitter } from "node:events";
+
+import { isCloudflareTcpSocket } from "./tcp.js";
+
+type IoredisErrorEmitter = (type: string, err: Error) => void;
+
+export 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;
+    #stream: IoredisNetStream | undefined;
+    #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/src/private-data-sources/manifest.ts

@@ -0,0 +1,127 @@
+import { workerEnvironment } from "./runtime-environment.js";
+import type { PrivateDataSourceManifestEntry } from "./types.js";
+
+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;
+}
+
+// The manifest is a Worker binding frozen with the script's Hyperdrive/VPC bindings,
+// so every entry it lists has its binding on this worker.
+function parsePrivateDataSourceManifest(): PrivateDataSourceManifestEntry[] {
+  const raw = readStringVar(PRIVATE_DATA_SOURCES_MANIFEST_ENV);
+  if (!raw) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  return Array.isArray(parsed)
+    ? parsed.filter(
+        (entry): entry is PrivateDataSourceManifestEntry =>
+          entry !== null && typeof entry === "object",
+      )
+    : [];
+}
+
+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 {
+  return lookupPrivateDataSource(requestedName, 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 app. Private data sources are available on the published app, not in the editor's live preview`,
+    );
+  }
+
+  const typeMatches = expectedType
+    ? matches.filter((candidate) => privateDataSourceMatchesExpectedType(candidate.entry, expectedType))
+    : matches;
+  const [best] = typeMatches;
+  if (!best) {
+    throw new Error(`Private data source "${requestedName}" is not a ${expectedType} data source`);
+  }
+
+  const bestMatches = typeMatches.filter((candidate) => candidate.rank === best.rank);
+  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 best.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/src/private-data-sources/mariadb.ts

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

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

@@ -0,0 +1,70 @@
+import {
+  currentPrivateDataSource,
+  normalizePrivateDataSourceKey,
+  privateDataSourceReference,
+} from "./manifest.js";
+import { buildTcpPrivateDataSource } from "./tcp.js";
+import { installPrivateNodeNetAdapter, registerPrivateNodeNetRoute } from "./node-net-adapter.js";
+import type { PrivateDataSourceManifestEntry } from "./types.js";
+
+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/src/private-data-sources/mysql.ts

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