@every-app/sdk 0.1.13 → 0.2.0

package/src/cloudflare/getLocalD1Url.ts

@@ -1,64 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { execSync } from "child_process";
-import { parse } from "jsonc-parser";
-
-function findSqliteFile(basePath: string): string | undefined {
-  return fs
-    .readdirSync(basePath, { encoding: "utf-8", recursive: true })
-    .find((f) => f.endsWith(".sqlite"));
-}
-
-export function getLocalD1Url() {
-  const basePath = path.resolve(".wrangler");
-
-  // Check if .wrangler directory exists
-  if (!fs.existsSync(basePath)) {
-    console.error(
-      "================================================================================",
-    );
-    console.error("WARNING: .wrangler directory not found");
-    console.error("This is expected in CI/non-development environments.");
-    console.error(
-      "The local D1 database is only available after running 'wrangler dev' which you can trigger by running 'npm run dev'.",
-    );
-    console.error(
-      "================================================================================",
-    );
-    return null;
-  }
-
-  let dbFile = findSqliteFile(basePath);
-
-  if (!dbFile) {
-    // Read wrangler.jsonc to get the database name
-    const wranglerConfigPath = path.resolve("wrangler.jsonc");
-    const wranglerConfig = parse(fs.readFileSync(wranglerConfigPath, "utf-8"));
-
-    const databaseName = wranglerConfig.d1_databases?.[0]?.database_name;
-
-    if (!databaseName) {
-      throw new Error(
-        "Could not find database_name in wrangler.jsonc d1_databases configuration",
-      );
-    }
-
-    // Execute the command to initialize the local database
-    console.log(`Initializing local D1 database: ${databaseName}...`);
-    execSync(
-      `npx wrangler d1 execute ${databaseName} --local --command "SELECT 1;"`,
-      { stdio: "pipe" },
-    );
-
-    // Try to find the db file again after initialization
-    dbFile = findSqliteFile(basePath);
-
-    if (!dbFile) {
-      throw new Error(
-        `Failed to initialize local D1 database. The sqlite file was not created.`,
-      );
-    }
-  }
-
-  return path.resolve(basePath, dbFile);
-}

package/src/cloudflare/index.ts

@@ -1 +0,0 @@
-export { lazyInitForWorkers } from "./lazyInit.js";

package/src/cloudflare/lazyInit.ts

@@ -1,67 +0,0 @@
-/**
- * Wraps a factory function in a Proxy to defer initialization until first access.
- * This prevents async operations (Like creating Tanstack DB Collections) from running in Cloudflare Workers' global scope.
- *
- * @param factory - A function that creates and returns the resource.
- *                  Must be a callback to defer execution; passing the value directly
- *                  would evaluate it at module load time, triggering the Cloudflare error.
- * @returns A Proxy that lazily initializes the resource on first property access
- *
- * @example
- * ```ts
- * export const myCollection = lazyInitForWorkers(() =>
- *   createCollection(queryCollectionOptions({
- *     queryKey: ["myData"],
- *     queryFn: async () => fetchData(),
- *     // ... other options
- *   }))
- * );
- * ```
- */
-export function lazyInitForWorkers<T extends object>(factory: () => T): T {
-  // Closure: This variable is captured by getInstance() and the Proxy traps below.
-  // It remains in memory as long as the returned Proxy is referenced, enabling singleton behavior.
-  let instance: T | null = null;
-
-  function getInstance() {
-    if (!instance) {
-      instance = factory();
-    }
-    return instance;
-  }
-
-  return new Proxy({} as T, {
-    get(_, prop) {
-      const inst = getInstance();
-      const value = inst[prop as keyof T];
-      // Bind methods to the instance to preserve `this` context
-      return typeof value === "function" ? value.bind(inst) : value;
-    },
-    set(_, prop, value) {
-      const inst = getInstance();
-      (inst as any)[prop] = value;
-      return true;
-    },
-    deleteProperty(_, prop) {
-      const inst = getInstance();
-      delete (inst as any)[prop];
-      return true;
-    },
-    has(_, prop) {
-      const inst = getInstance();
-      return prop in inst;
-    },
-    ownKeys(_) {
-      const inst = getInstance();
-      return Reflect.ownKeys(inst);
-    },
-    getOwnPropertyDescriptor(_, prop) {
-      const inst = getInstance();
-      return Reflect.getOwnPropertyDescriptor(inst, prop);
-    },
-    getPrototypeOf(_) {
-      const inst = getInstance();
-      return Reflect.getPrototypeOf(inst);
-    },
-  });
-}

package/src/cloudflare/server/gateway.test.ts

@@ -1,262 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { fetchGateway, getGatewayUrl } from "./gateway";
-
-type TestFetcher = {
-  fetch: ReturnType<typeof vi.fn>;
-};
-
-type TestEnv = {
-  GATEWAY_URL?: string;
-  EVERY_APP_GATEWAY?: TestFetcher;
-  GATEWAY_APP_API_TOKEN?: string;
-  APP_TOKEN?: string;
-};
-
-describe("gateway server helpers", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("returns gateway URL and throws when missing", () => {
-    expect(getGatewayUrl({ GATEWAY_URL: "https://gateway.example.com" })).toBe(
-      "https://gateway.example.com",
-    );
-
-    expect(() => getGatewayUrl({} as TestEnv)).toThrow(
-      "GATEWAY_URL is required",
-    );
-  });
-
-  it("fetches via HTTP when service binding is unavailable", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      GATEWAY_APP_API_TOKEN: "eat_test_token",
-    };
-
-    await fetchGateway({
-      env,
-      url: "/api/ai/openai/v1/responses?stream=true",
-      init: { method: "POST" },
-    });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [requestArg] = fetchMock.mock.calls[0];
-    const request = requestArg as Request;
-
-    expect(request.url).toBe(
-      "https://gateway.example.com/api/ai/openai/v1/responses?stream=true",
-    );
-  });
-
-  it("throws when absolute URL points to non-gateway origin", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      GATEWAY_APP_API_TOKEN: "eat_test_token",
-    };
-
-    await expect(
-      fetchGateway({
-        env,
-        url: "https://evil.example.com/api/ai/openai/v1/responses",
-        init: { method: "POST" },
-      }),
-    ).rejects.toThrow(
-      "Refusing to send gateway token to non-gateway origin: https://evil.example.com",
-    );
-
-    expect(fetchMock).not.toHaveBeenCalled();
-  });
-
-  it("allows absolute URL when it matches gateway origin", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      GATEWAY_APP_API_TOKEN: "eat_test_token",
-    };
-
-    await fetchGateway({
-      env,
-      url: "https://gateway.example.com/api/ai/openai/v1/responses",
-      init: { method: "POST" },
-    });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [requestArg] = fetchMock.mock.calls[0];
-    const request = requestArg as Request;
-    expect(request.url).toBe(
-      "https://gateway.example.com/api/ai/openai/v1/responses",
-    );
-  });
-
-  it("fetches via service binding when available in production", async () => {
-    // Service binding is only used when import.meta.env.PROD is true
-    const originalProd = import.meta.env.PROD;
-    import.meta.env.PROD = true;
-
-    try {
-      const bindingFetch = vi
-        .fn()
-        .mockResolvedValue(new Response("ok", { status: 200 }));
-
-      const env: TestEnv = {
-        GATEWAY_URL: "https://gateway.example.com",
-        EVERY_APP_GATEWAY: { fetch: bindingFetch },
-        GATEWAY_APP_API_TOKEN: "eat_test_token",
-      };
-
-      await fetchGateway({
-        env,
-        url: "/api/ai/openai/v1/chat/completions",
-        init: { method: "POST" },
-      });
-
-      expect(bindingFetch).toHaveBeenCalledTimes(1);
-      const [requestArg] = bindingFetch.mock.calls[0];
-      const request = requestArg as Request;
-      expect(request.url).toBe(
-        "http://localhost/api/ai/openai/v1/chat/completions",
-      );
-    } finally {
-      import.meta.env.PROD = originalProd;
-    }
-  });
-
-  it("skips service binding in development and uses HTTP fetch", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const bindingFetch = vi.fn();
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      EVERY_APP_GATEWAY: { fetch: bindingFetch },
-      GATEWAY_APP_API_TOKEN: "eat_test_token",
-    };
-
-    await fetchGateway({
-      env,
-      url: "/api/ai/openai/v1/chat/completions",
-      init: { method: "POST" },
-    });
-
-    // In dev, should use HTTP fetch, not service binding
-    expect(bindingFetch).not.toHaveBeenCalled();
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("always injects app token and strips Authorization header", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      GATEWAY_APP_API_TOKEN: "eat_my_token",
-    };
-
-    await fetchGateway({
-      env,
-      url: "/api/ai/openai/v1/responses",
-      init: {
-        method: "POST",
-        headers: {
-          authorization: "Bearer some-sdk-dummy-value",
-        },
-      },
-    });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [requestArg] = fetchMock.mock.calls[0];
-    const request = requestArg as Request;
-
-    expect(request.headers.get("x-every-app-token")).toBe("eat_my_token");
-    expect(request.headers.get("authorization")).toBeNull();
-  });
-
-  it("throws when app token is missing", async () => {
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-    };
-
-    await expect(
-      fetchGateway({
-        env,
-        url: "/api/ai/openai/v1/responses",
-      }),
-    ).rejects.toThrow("GATEWAY_APP_API_TOKEN is required");
-  });
-
-  it("supports legacy APP_TOKEN env variable", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      APP_TOKEN: "eat_legacy_token",
-    };
-
-    await fetchGateway({
-      env,
-      url: "/api/ai/openai/v1/responses",
-      init: { method: "POST" },
-    });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [requestArg] = fetchMock.mock.calls[0];
-    const request = requestArg as Request;
-
-    expect(request.headers.get("x-every-app-token")).toBe("eat_legacy_token");
-    expect(request.headers.get("authorization")).toBeNull();
-  });
-
-  it("supports Request input and preserves method/body", async () => {
-    const fetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("ok", { status: 200 }));
-
-    const env: TestEnv = {
-      GATEWAY_URL: "https://gateway.example.com",
-      GATEWAY_APP_API_TOKEN: "eat_test_token",
-    };
-
-    const sourceRequest = new Request(
-      "https://gateway.example.com/api/ai/openai/v1/responses",
-      {
-        method: "POST",
-        body: JSON.stringify({ model: "gpt-5.2" }),
-        headers: { "content-type": "application/json" },
-      },
-    );
-
-    await fetchGateway({
-      env,
-      url: sourceRequest,
-    });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [requestArg] = fetchMock.mock.calls[0];
-    const request = requestArg as Request;
-    expect(request.url).toBe(
-      "https://gateway.example.com/api/ai/openai/v1/responses",
-    );
-    expect(request.method).toBe("POST");
-    expect(request.headers.get("content-type")).toBe("application/json");
-  });
-});

package/src/cloudflare/server/gateway.ts

@@ -1,114 +0,0 @@
-const SERVICE_BINDING_ORIGIN = "http://localhost";
-const APP_TOKEN_HEADER = "x-every-app-token";
-
-interface GatewayFetcher {
-  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
-}
-
-interface GatewayEnv {
-  GATEWAY_URL?: string;
-  EVERY_APP_GATEWAY?: GatewayFetcher;
-  GATEWAY_APP_API_TOKEN?: string;
-  APP_TOKEN?: string;
-}
-
-interface FetchGatewayOptions {
-  env: GatewayEnv;
-  /** The URL, path, or Request to send to the gateway. Typically the full URL
-   *  passed by a provider SDK's custom `fetch` override. */
-  url: string | URL | Request;
-  /** Standard `RequestInit` (method, headers, body, etc.) from the provider SDK. */
-  init?: RequestInit;
-}
-
-export function getGatewayUrl(env: GatewayEnv): string {
-  const gatewayUrl = env.GATEWAY_URL?.trim();
-  if (!gatewayUrl) {
-    throw new Error("GATEWAY_URL is required");
-  }
-  return gatewayUrl;
-}
-
-/**
- * Fetch from the gateway proxy, authenticating with the app token.
- *
- * - Strips any existing `Authorization` header (the gateway only accepts
- *   app token auth via `x-every-app-token`).
- * - Requires `GATEWAY_APP_API_TOKEN` (or legacy `APP_TOKEN`) in the env.
- * - Routes via service binding in production, falls back to HTTP in dev.
- */
-export async function fetchGateway({
-  env,
-  url,
-  init,
-}: FetchGatewayOptions): Promise<Response> {
-  const gatewayBaseUrl = getGatewayUrl(env);
-  const resolvedRequest = toRequest(url, init, gatewayBaseUrl);
-  const authenticatedRequest = applyAppTokenAuth(resolvedRequest, env);
-
-  // Use service binding in production for zero-latency internal routing.
-  // In local dev wrangler still exposes the binding object, but the target
-  // service usually isn't running locally, so we skip it and use HTTP fetch.
-  if (import.meta.env.PROD && env.EVERY_APP_GATEWAY) {
-    const url = new URL(authenticatedRequest.url);
-    const bindingUrl = `${SERVICE_BINDING_ORIGIN}${url.pathname}${url.search}`;
-    const bindingRequest = new Request(bindingUrl, authenticatedRequest);
-    return env.EVERY_APP_GATEWAY.fetch(bindingRequest);
-  }
-
-  // HTTP fetch – used in local dev, or as a fallback when no binding exists
-  return fetch(authenticatedRequest);
-}
-
-function applyAppTokenAuth(request: Request, env: GatewayEnv): Request {
-  const gatewayOrigin = new URL(getGatewayUrl(env)).origin;
-  const requestOrigin = new URL(request.url).origin;
-  if (requestOrigin !== gatewayOrigin) {
-    throw new Error(
-      `Refusing to send gateway token to non-gateway origin: ${requestOrigin}`,
-    );
-  }
-
-  const appToken = getGatewayAppApiToken(env);
-  if (!appToken) {
-    throw new Error(
-      "GATEWAY_APP_API_TOKEN is required. Run `npx everyapp app deploy` to provision one.",
-    );
-  }
-
-  const headers = new Headers(request.headers);
-  headers.delete("authorization");
-  headers.set(APP_TOKEN_HEADER, appToken);
-  return new Request(request, { headers });
-}
-
-function getGatewayAppApiToken(env: GatewayEnv): string | null {
-  const configuredToken = env.GATEWAY_APP_API_TOKEN?.trim();
-  if (configuredToken) {
-    return configuredToken;
-  }
-
-  const legacyToken = env.APP_TOKEN?.trim();
-  return legacyToken || null;
-}
-
-function toRequest(
-  input: RequestInfo | URL,
-  init?: RequestInit,
-  baseUrl?: string,
-): Request {
-  if (input instanceof Request) {
-    return init ? new Request(input, init) : input;
-  }
-
-  if (input instanceof URL) {
-    return new Request(input.toString(), init);
-  }
-
-  if (typeof input === "string" && baseUrl && !/^https?:\/\//i.test(input)) {
-    const normalizedPath = input.startsWith("/") ? input : `/${input}`;
-    return new Request(new URL(normalizedPath, baseUrl).toString(), init);
-  }
-
-  return new Request(input, init);
-}

package/src/cloudflare/server/index.ts

@@ -1,2 +0,0 @@
-export { getLocalD1Url } from "../getLocalD1Url.js";
-export { fetchGateway, getGatewayUrl } from "./gateway.js";

package/src/core/authenticatedFetch.ts

@@ -1,54 +0,0 @@
-import {
-  BYPASS_GATEWAY_LOCAL_ONLY_TOKEN,
-  isBypassGatewayLocalOnlyClient,
-} from "../shared/bypassGatewayLocalOnly.js";
-
-interface SessionManager {
-  getToken(): Promise<string>;
-}
-
-interface WindowWithSessionManager extends Window {
-  __embeddedSessionManager?: SessionManager;
-}
-
-/**
- * Gets the current session token from the embedded session manager
- */
-export async function getSessionToken(): Promise<string> {
-  if (isBypassGatewayLocalOnlyClient()) {
-    return BYPASS_GATEWAY_LOCAL_ONLY_TOKEN;
-  }
-
-  const windowWithSession = window as WindowWithSessionManager;
-  const sessionManager = windowWithSession.__embeddedSessionManager;
-
-  if (!sessionManager) {
-    throw new Error("Session manager not available");
-  }
-
-  const token = await sessionManager.getToken();
-
-  if (!token) {
-    throw new Error("No token available");
-  }
-
-  return token;
-}
-
-/**
- * Performs a fetch request with the authorization header automatically added
- */
-export async function authenticatedFetch(
-  input: RequestInfo | URL,
-  init?: RequestInit,
-): Promise<Response> {
-  const token = await getSessionToken();
-
-  const headers = new Headers(init?.headers);
-  headers.set("Authorization", `Bearer ${token}`);
-
-  return fetch(input, {
-    ...init,
-    headers,
-  });
-}

package/src/core/index.ts

@@ -1,12 +0,0 @@
-export {
-  SessionManager,
-  isRunningInIframe,
-  isRunningInReactNativeWebView,
-  detectEnvironment,
-} from "./sessionManager.js";
-export type {
-  SessionManagerConfig,
-  EmbeddedEnvironment,
-} from "./sessionManager.js";
-
-export { authenticatedFetch, getSessionToken } from "./authenticatedFetch.js";