@staticbot/base44-supabase-shim 0.3.0

package/dist/types-HIZDZaWa.d.cts

@@ -0,0 +1,115 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+interface EntityMapping {
+    schema: string;
+    table: string;
+}
+interface ClientOptions {
+    /** Supabase project URL, e.g. https://api.erp.local */
+    supabaseUrl: string;
+    /** anon public key for browser use */
+    supabaseAnonKey: string;
+    /** service_role key — only set in trusted server contexts */
+    supabaseServiceRoleKey?: string;
+    /**
+     * Postgres schema for app-specific entities.
+     * E.g. 'propertyflow' / 'fms' / 'finance' / 'construction'.
+     */
+    schemaPrefix: string;
+    /**
+     * Postgres schema for shared entities (Customer, Company, User, Role...).
+     * Default: 'core'.
+     */
+    sharedSchema?: string;
+    /**
+     * List of entity names that live in `sharedSchema` instead of `schemaPrefix`.
+     * Default: ['Customer', 'Company', 'User', 'Role', 'Department', 'Notification', 'AuditLog'].
+     */
+    sharedEntities?: string[];
+    /**
+     * Explicit per-entity mapping overrides. Use this if the auto-derived
+     * snake_case+pluralize naming doesn't match the actual table name.
+     */
+    entityMap?: Record<string, EntityMapping>;
+    /**
+     * Optional pre-built supabase client. If omitted, one is created from the keys.
+     * Useful in tests / when you already have a client elsewhere.
+     */
+    client?: SupabaseClient;
+}
+interface OrderBy {
+    /** Field name. Prefix with '-' for descending (Base44 convention). */
+    field: string;
+    ascending?: boolean;
+}
+/** Where-clause filter object as used by Base44.
+ *
+ * Three accepted shapes per field, all translated to PostgREST:
+ *
+ *   1. Equality / array shorthand:   `{ status: 'active', id: ['a','b'] }`
+ *   2. Base44 SDK Mongo operators:   `{ price: { $gte: 10, $lt: 100 }, status: { $in: ['a','b'] } }`
+ *   3. Legacy {op,value} form:       `{ amount: { op: 'gt', value: 100 } }`
+ *
+ * Shape (2) is what `@base44/sdk` emits — its `entities.X.filter(q, ...)`
+ * forwards `q` to Base44's REST as URL-encoded JSON with $-prefixed ops.
+ * Apps that ran against Base44's managed backend pass these exact shapes.
+ */
+type MongoFilter = {
+    $eq?: unknown;
+    $ne?: unknown;
+    $gt?: unknown;
+    $gte?: unknown;
+    $lt?: unknown;
+    $lte?: unknown;
+    $in?: unknown[];
+    $nin?: unknown[];
+    $like?: string;
+    $ilike?: string;
+};
+type FilterValue = string | number | boolean | null | string[] | number[] | MongoFilter | {
+    op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in';
+    value: unknown;
+};
+type FilterObject = Record<string, FilterValue>;
+interface EntityApi<T = Record<string, unknown>> {
+    list(orderBy?: string | OrderBy, limit?: number, skip?: number): Promise<T[]>;
+    filter(where: FilterObject, orderBy?: string | OrderBy, limit?: number, skip?: number): Promise<T[]>;
+    get(id: string): Promise<T | null>;
+    /** Alias for get() — Base44 SDK exposes both names. */
+    read(id: string): Promise<T | null>;
+    create(body: Partial<T>): Promise<T>;
+    /** Insert multiple rows in one call. */
+    bulkCreate(rows: Array<Partial<T>>): Promise<T[]>;
+    /** Update many rows by id; each row must contain its own `id`. */
+    bulkUpdate(rows: Array<Partial<T> & {
+        id: string;
+    }>): Promise<T[]>;
+    update(id: string, body: Partial<T>): Promise<T>;
+    /**
+     * Apply the same patch to every row matching `where`. Accepts either a flat
+     * patch or a MongoDB-style `{ $set: {...} }` envelope (the Base44 SDK form).
+     */
+    updateMany(where: FilterObject, update: Partial<T> | {
+        $set?: Partial<T>;
+    }): Promise<T[]>;
+    delete(id: string): Promise<void>;
+    /** Delete every row matching `where`. */
+    deleteMany(where: FilterObject): Promise<void>;
+    /**
+     * Subscribe to row changes via Supabase Realtime.
+     * Returns an unsubscribe function (matches Base44 convention).
+     */
+    subscribe(callback: (event: {
+        type: 'insert' | 'update' | 'delete';
+        new?: T;
+        old?: T;
+    }) => void): () => void;
+}
+type EntitiesProxy = {
+    [entityName: string]: EntityApi;
+};
+
+export type { ClientOptions as C, EntityMapping as E, FilterObject as F, Json as J, MongoFilter as M, OrderBy as O, EntitiesProxy as a, EntityApi as b, FilterValue as c };

package/dist/types-HIZDZaWa.d.ts

@@ -0,0 +1,115 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+type Json = string | number | boolean | null | Json[] | {
+    [key: string]: Json;
+};
+interface EntityMapping {
+    schema: string;
+    table: string;
+}
+interface ClientOptions {
+    /** Supabase project URL, e.g. https://api.erp.local */
+    supabaseUrl: string;
+    /** anon public key for browser use */
+    supabaseAnonKey: string;
+    /** service_role key — only set in trusted server contexts */
+    supabaseServiceRoleKey?: string;
+    /**
+     * Postgres schema for app-specific entities.
+     * E.g. 'propertyflow' / 'fms' / 'finance' / 'construction'.
+     */
+    schemaPrefix: string;
+    /**
+     * Postgres schema for shared entities (Customer, Company, User, Role...).
+     * Default: 'core'.
+     */
+    sharedSchema?: string;
+    /**
+     * List of entity names that live in `sharedSchema` instead of `schemaPrefix`.
+     * Default: ['Customer', 'Company', 'User', 'Role', 'Department', 'Notification', 'AuditLog'].
+     */
+    sharedEntities?: string[];
+    /**
+     * Explicit per-entity mapping overrides. Use this if the auto-derived
+     * snake_case+pluralize naming doesn't match the actual table name.
+     */
+    entityMap?: Record<string, EntityMapping>;
+    /**
+     * Optional pre-built supabase client. If omitted, one is created from the keys.
+     * Useful in tests / when you already have a client elsewhere.
+     */
+    client?: SupabaseClient;
+}
+interface OrderBy {
+    /** Field name. Prefix with '-' for descending (Base44 convention). */
+    field: string;
+    ascending?: boolean;
+}
+/** Where-clause filter object as used by Base44.
+ *
+ * Three accepted shapes per field, all translated to PostgREST:
+ *
+ *   1. Equality / array shorthand:   `{ status: 'active', id: ['a','b'] }`
+ *   2. Base44 SDK Mongo operators:   `{ price: { $gte: 10, $lt: 100 }, status: { $in: ['a','b'] } }`
+ *   3. Legacy {op,value} form:       `{ amount: { op: 'gt', value: 100 } }`
+ *
+ * Shape (2) is what `@base44/sdk` emits — its `entities.X.filter(q, ...)`
+ * forwards `q` to Base44's REST as URL-encoded JSON with $-prefixed ops.
+ * Apps that ran against Base44's managed backend pass these exact shapes.
+ */
+type MongoFilter = {
+    $eq?: unknown;
+    $ne?: unknown;
+    $gt?: unknown;
+    $gte?: unknown;
+    $lt?: unknown;
+    $lte?: unknown;
+    $in?: unknown[];
+    $nin?: unknown[];
+    $like?: string;
+    $ilike?: string;
+};
+type FilterValue = string | number | boolean | null | string[] | number[] | MongoFilter | {
+    op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in';
+    value: unknown;
+};
+type FilterObject = Record<string, FilterValue>;
+interface EntityApi<T = Record<string, unknown>> {
+    list(orderBy?: string | OrderBy, limit?: number, skip?: number): Promise<T[]>;
+    filter(where: FilterObject, orderBy?: string | OrderBy, limit?: number, skip?: number): Promise<T[]>;
+    get(id: string): Promise<T | null>;
+    /** Alias for get() — Base44 SDK exposes both names. */
+    read(id: string): Promise<T | null>;
+    create(body: Partial<T>): Promise<T>;
+    /** Insert multiple rows in one call. */
+    bulkCreate(rows: Array<Partial<T>>): Promise<T[]>;
+    /** Update many rows by id; each row must contain its own `id`. */
+    bulkUpdate(rows: Array<Partial<T> & {
+        id: string;
+    }>): Promise<T[]>;
+    update(id: string, body: Partial<T>): Promise<T>;
+    /**
+     * Apply the same patch to every row matching `where`. Accepts either a flat
+     * patch or a MongoDB-style `{ $set: {...} }` envelope (the Base44 SDK form).
+     */
+    updateMany(where: FilterObject, update: Partial<T> | {
+        $set?: Partial<T>;
+    }): Promise<T[]>;
+    delete(id: string): Promise<void>;
+    /** Delete every row matching `where`. */
+    deleteMany(where: FilterObject): Promise<void>;
+    /**
+     * Subscribe to row changes via Supabase Realtime.
+     * Returns an unsubscribe function (matches Base44 convention).
+     */
+    subscribe(callback: (event: {
+        type: 'insert' | 'update' | 'delete';
+        new?: T;
+        old?: T;
+    }) => void): () => void;
+}
+type EntitiesProxy = {
+    [entityName: string]: EntityApi;
+};
+
+export type { ClientOptions as C, EntityMapping as E, FilterObject as F, Json as J, MongoFilter as M, OrderBy as O, EntitiesProxy as a, EntityApi as b, FilterValue as c };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@staticbot/base44-supabase-shim",
+  "version": "0.3.0",
+  "description": "Drop-in shim mimicking @base44/sdk API but routing to a Supabase backend. Used by Staticbot's Base44 native migration to keep migrated apps building without an npm registry round-trip.",
+  "license": "MIT",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/staticbot/staticbot-base44-supabase-shim.git"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "require": "./dist/server.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": {
+    "@supabase/supabase-js": "^2.45.0"
+  },
+  "devDependencies": {
+    "@supabase/supabase-js": "^2.45.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,101 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+export interface SignInArgs {
+  email: string;
+  password: string;
+}
+
+export interface SignUpArgs {
+  email: string;
+  password: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AuthOptions {
+  /**
+   * Browser path the redirectToLogin() shim should send users to.
+   * Default: '/login'.
+   */
+  loginPath?: string;
+}
+
+export function makeAuth(client: SupabaseClient, opts: AuthOptions = {}) {
+  const loginPath = opts.loginPath ?? '/login';
+
+  return {
+    async signIn({ email, password }: SignInArgs) {
+      const { data, error } = await client.auth.signInWithPassword({ email, password });
+      if (error) throw error;
+      return data;
+    },
+    async signUp({ email, password, metadata }: SignUpArgs) {
+      const { data, error } = await client.auth.signUp({
+        email,
+        password,
+        options: { data: metadata ?? {} },
+      });
+      if (error) throw error;
+      return data;
+    },
+    async signOut() {
+      const { error } = await client.auth.signOut();
+      if (error) throw error;
+    },
+    /** Base44 alias for signOut. */
+    async logout() {
+      const { error } = await client.auth.signOut();
+      if (error) throw error;
+    },
+    async getUser() {
+      const { data, error } = await client.auth.getUser();
+      if (error) throw error;
+      return data.user;
+    },
+    /** Base44 alias for getUser. Returns the current user object or throws if not signed in. */
+    async me() {
+      const { data, error } = await client.auth.getUser();
+      if (error) throw error;
+      if (!data.user) throw new Error('Not authenticated');
+      return data.user;
+    },
+    /**
+     * Base44 alias for updating the current user's metadata. Accepts arbitrary
+     * key/value pairs that get stored in `user_metadata`.
+     */
+    async updateMe(metadata: Record<string, unknown>) {
+      const { data, error } = await client.auth.updateUser({ data: metadata });
+      if (error) throw error;
+      return data.user;
+    },
+    async getSession() {
+      const { data, error } = await client.auth.getSession();
+      if (error) throw error;
+      return data.session;
+    },
+    /**
+     * Base44 used to redirect SPA users to its hosted login page. Self-host
+     * has no hosted login, so this just navigates to the configured local
+     * loginPath. Override the path via createClient({ ..., authLoginPath: '/x' }).
+     */
+    redirectToLogin(returnUrl?: string) {
+      if (typeof window === 'undefined') return;
+      // Already on the login route → no-op. Prevents redirect loops when an
+      // unauthenticated check on /login itself fires another redirectToLogin.
+      if (window.location.pathname === loginPath) return;
+      // Defensive: if the returnUrl already points back to a login page (cyclic
+      // chain from old buggy state), drop it. Also drop if it's absurdly long.
+      let safeReturn: string | undefined = returnUrl;
+      if (safeReturn) {
+        const looksCyclic = safeReturn.includes(`${loginPath}?next=`) || safeReturn.includes(`${loginPath}%3F`);
+        if (looksCyclic || safeReturn.length > 1024) safeReturn = undefined;
+      }
+      const url = safeReturn
+        ? `${loginPath}?next=${encodeURIComponent(safeReturn)}`
+        : loginPath;
+      window.location.assign(url);
+    },
+    onAuthStateChange(cb: Parameters<SupabaseClient['auth']['onAuthStateChange']>[0]) {
+      return client.auth.onAuthStateChange(cb);
+    },
+  };
+}

package/src/entities.ts

@@ -0,0 +1,267 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type {
+  ClientOptions,
+  EntitiesProxy,
+  EntityApi,
+  EntityMapping,
+  FilterObject,
+  FilterValue,
+  OrderBy,
+} from './types.js';
+
+const DEFAULT_SHARED_ENTITIES = [
+  // Auth/identity (option C: shared)
+  'User',
+  'Role',
+  'UserRole',      // 'finance.user_roles' was 404 — UserRole belongs in shared
+  'Department',
+  // Org (option C: shared)
+  'Company',
+  // Cross-app entities exposed by core schema
+  'AuditLog',
+  // Note: Customer is intentionally NOT shared — each app's Customer schema
+  // differs significantly (CRM vs Facility vs Construction).
+];
+
+/** PascalCase → snake_case + naive pluralization (s, ies, es). */
+export function defaultEntityToTable(entityName: string): string {
+  const snake = entityName.replace(/([A-Z])/g, (m, c, i) =>
+    i === 0 ? c.toLowerCase() : '_' + c.toLowerCase(),
+  );
+  if (snake.endsWith('y') && !/[aeiou]y$/.test(snake)) return snake.slice(0, -1) + 'ies';
+  if (/(s|x|z|ch|sh)$/.test(snake)) return snake + 'es';
+  return snake + 's';
+}
+
+export function resolveEntityMapping(
+  entityName: string,
+  opts: Required<Pick<ClientOptions, 'schemaPrefix'>> &
+    Pick<ClientOptions, 'sharedSchema' | 'sharedEntities' | 'entityMap'>,
+): EntityMapping {
+  if (opts.entityMap?.[entityName]) return opts.entityMap[entityName];
+  const sharedEntities = opts.sharedEntities ?? DEFAULT_SHARED_ENTITIES;
+  const sharedSchema = opts.sharedSchema ?? 'core';
+  const schema = sharedEntities.includes(entityName) ? sharedSchema : opts.schemaPrefix;
+  return { schema, table: defaultEntityToTable(entityName) };
+}
+
+/**
+ * Parse Base44-style orderBy:
+ *   - string '-created_date' → { field: 'created_date', ascending: false }
+ *   - string 'name' → { field: 'name', ascending: true }
+ *   - object passes through.
+ */
+export function parseOrderBy(input: string | OrderBy | undefined): OrderBy | undefined {
+  if (!input) return undefined;
+  if (typeof input === 'object') return input;
+  if (input.startsWith('-')) return { field: input.slice(1), ascending: false };
+  return { field: input, ascending: true };
+}
+
+const MONGO_OPS = [
+  '$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin', '$like', '$ilike',
+] as const;
+
+function isMongoFilter(v: unknown): v is Record<string, unknown> {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return false;
+  return Object.keys(v as object).some((k) =>
+    (MONGO_OPS as readonly string[]).includes(k),
+  );
+}
+
+function applyMongoOps(query: any, field: string, ops: Record<string, unknown>): any {
+  for (const [op, value] of Object.entries(ops)) {
+    switch (op) {
+      case '$eq':    query = query.eq(field, value); break;
+      case '$ne':    query = query.neq(field, value); break;
+      case '$gt':    query = query.gt(field, value); break;
+      case '$gte':   query = query.gte(field, value); break;
+      case '$lt':    query = query.lt(field, value); break;
+      case '$lte':   query = query.lte(field, value); break;
+      case '$in':    query = query.in(field, value as unknown[]); break;
+      case '$nin':   query = query.not('in', `(${(value as unknown[]).map(v => JSON.stringify(v)).join(',')})`); break;
+      case '$like':  query = query.like(field, value as string); break;
+      case '$ilike': query = query.ilike(field, value as string); break;
+      // Unknown ops are ignored rather than throwing — keeps shim forward-
+      // compatible if Base44 ships new operators we haven't seen yet.
+    }
+  }
+  return query;
+}
+
+function applyFilter(query: any, where: FilterObject): any {
+  for (const [field, raw] of Object.entries(where)) {
+    const v = raw as FilterValue;
+    if (v === null) {
+      query = query.is(field, null);
+    } else if (isMongoFilter(v)) {
+      query = applyMongoOps(query, field, v as Record<string, unknown>);
+    } else if (typeof v === 'object' && !Array.isArray(v) && 'op' in v) {
+      // legacy {op, value} form — translate to the Mongo path so behaviour stays in sync
+      const { op, value } = v as { op: string; value: unknown };
+      query = applyMongoOps(query, field, { [`$${op}`]: value });
+    } else if (Array.isArray(v)) {
+      query = query.in(field, v);
+    } else {
+      query = query.eq(field, v);
+    }
+  }
+  return query;
+}
+
+function applyRange(query: any, limit: number | undefined, skip: number | undefined): any {
+  if (typeof skip === 'number' && typeof limit === 'number') {
+    return query.range(skip, skip + limit - 1);
+  }
+  if (typeof limit === 'number') return query.limit(limit);
+  return query;
+}
+
+export function makeEntityApi(client: SupabaseClient, mapping: EntityMapping): EntityApi {
+  const from = () => client.schema(mapping.schema as never).from(mapping.table);
+
+  // Treat "table not in schema cache" (PGRST205) and 404 as empty result, not error.
+  // Apps reference many entities that may not exist in self-host schema yet —
+  // surfacing as empty lets the UI render skeletons instead of crashing.
+  const isMissingTableError = (e: unknown): boolean => {
+    if (!e || typeof e !== 'object') return false;
+    const code = (e as { code?: string }).code;
+    const status = (e as { status?: number }).status;
+    return code === 'PGRST205' || code === '42P01' || status === 404;
+  };
+  const warnedTables = new Set<string>();
+  const warnMissing = () => {
+    const key = `${mapping.schema}.${mapping.table}`;
+    if (warnedTables.has(key)) return;
+    warnedTables.add(key);
+    if (typeof console !== 'undefined') console.warn(`[base44-shim] table ${key} not found — returning empty result`);
+  };
+
+  return {
+    async list(orderBy, limit, skip) {
+      let q = from().select('*');
+      const ob = parseOrderBy(orderBy);
+      if (ob) q = q.order(ob.field, { ascending: ob.ascending ?? true });
+      q = applyRange(q, limit, skip);
+      const { data, error } = await q;
+      if (error) {
+        if (isMissingTableError(error)) { warnMissing(); return []; }
+        throw error;
+      }
+      return data ?? [];
+    },
+    async filter(where, orderBy, limit, skip) {
+      let q = from().select('*');
+      q = applyFilter(q, where);
+      const ob = parseOrderBy(orderBy);
+      if (ob) q = q.order(ob.field, { ascending: ob.ascending ?? true });
+      q = applyRange(q, limit, skip);
+      const { data, error } = await q;
+      if (error) {
+        if (isMissingTableError(error)) { warnMissing(); return []; }
+        throw error;
+      }
+      return data ?? [];
+    },
+    async get(id) {
+      const { data, error } = await from().select('*').eq('id', id).maybeSingle();
+      if (error) {
+        if (isMissingTableError(error)) { warnMissing(); return null; }
+        throw error;
+      }
+      return data ?? null;
+    },
+    async read(id) {
+      const { data, error } = await from().select('*').eq('id', id).maybeSingle();
+      if (error) {
+        if (isMissingTableError(error)) { warnMissing(); return null; }
+        throw error;
+      }
+      return data ?? null;
+    },
+    async create(body) {
+      const { data, error } = await from().insert(body).select().single();
+      if (error) throw error;
+      return data;
+    },
+    async bulkCreate(rows) {
+      if (!rows.length) return [];
+      const { data, error } = await from().insert(rows).select();
+      if (error) throw error;
+      return data ?? [];
+    },
+    async update(id, body) {
+      const { data, error } = await from().update(body).eq('id', id).select().single();
+      if (error) throw error;
+      return data;
+    },
+    async bulkUpdate(rows) {
+      if (!rows.length) return [];
+      // PostgREST has no native multi-patch with per-row payloads; do one
+      // round-trip per row. Fine for hundreds — re-evaluate if a caller
+      // starts pushing thousands and we need a CTE-based RPC.
+      const results = await Promise.all(
+        rows.map(({ id, ...patch }) =>
+          from().update(patch).eq('id', id).select().single(),
+        ),
+      );
+      const errors = results.map((r) => r.error).filter(Boolean);
+      if (errors.length) throw errors[0];
+      return results.map((r) => r.data) as any[];
+    },
+    async updateMany(where, update) {
+      // Base44 SDK / Mongo style: `{ $set: { field: value } }` wraps the patch.
+      // Unwrap so the same call works whether the caller used $set or a flat object.
+      const patch = (update as { $set?: unknown })?.$set ?? update;
+      let q = from().update(patch as Record<string, unknown>);
+      q = applyFilter(q, where);
+      const { data, error } = await q.select();
+      if (error) throw error;
+      return data ?? [];
+    },
+    async delete(id) {
+      const { error } = await from().delete().eq('id', id);
+      if (error) throw error;
+    },
+    async deleteMany(where) {
+      let q = from().delete();
+      q = applyFilter(q, where);
+      const { error } = await q;
+      if (error) throw error;
+    },
+    subscribe(callback) {
+      const channel = client
+        .channel(`${mapping.schema}.${mapping.table}.${Math.random().toString(36).slice(2, 8)}`)
+        .on(
+          'postgres_changes' as never,
+          { event: '*', schema: mapping.schema, table: mapping.table },
+          (payload: { eventType: string; new?: unknown; old?: unknown }) => {
+            const type = payload.eventType.toLowerCase() as 'insert' | 'update' | 'delete';
+            callback({ type, new: payload.new as never, old: payload.old as never });
+          },
+        )
+        .subscribe();
+      return () => {
+        void client.removeChannel(channel);
+      };
+    },
+  };
+}
+
+export function makeEntitiesProxy(
+  client: SupabaseClient,
+  opts: Required<Pick<ClientOptions, 'schemaPrefix'>> &
+    Pick<ClientOptions, 'sharedSchema' | 'sharedEntities' | 'entityMap'>,
+): EntitiesProxy {
+  const cache: Record<string, EntityApi> = {};
+  return new Proxy({} as EntitiesProxy, {
+    get(_target, prop: string) {
+      if (typeof prop !== 'string') return undefined;
+      if (!cache[prop]) {
+        const mapping = resolveEntityMapping(prop, opts);
+        cache[prop] = makeEntityApi(client, mapping);
+      }
+      return cache[prop];
+    },
+  });
+}

package/src/functions.ts

@@ -0,0 +1,28 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+/** Mirror of base44.functions — Supabase Edge Functions invoke wrapper.
+ *
+ *  Returns the raw body. On HTTP error, throws an Error with the response body attached.
+ */
+export function makeFunctions(client: SupabaseClient) {
+  return {
+    /** Invoke an edge function by name, passing JSON body. Returns parsed JSON. */
+    async invoke<T = unknown>(name: string, payload?: Record<string, unknown>): Promise<T> {
+      const { data, error } = await client.functions.invoke<T>(name, {
+        body: payload,
+      });
+      if (error) throw error;
+      return data as T;
+    },
+    /** Lower-level: invoke and return Response so caller can handle non-JSON. */
+    async fetch(name: string, init?: RequestInit): Promise<Response> {
+      const url = `${(client as unknown as { supabaseUrl: string }).supabaseUrl}/functions/v1/${name}`;
+      const headers = new Headers(init?.headers);
+      const session = await client.auth.getSession();
+      const token = session.data.session?.access_token;
+      if (token) headers.set('Authorization', `Bearer ${token}`);
+      headers.set('apikey', (client as unknown as { supabaseKey: string }).supabaseKey);
+      return fetch(url, { ...init, headers });
+    },
+  };
+}