@staticbot/base44-supabase-shim 0.3.0

package/src/index.ts

@@ -0,0 +1,97 @@
+import { createClient as createSupabase, type SupabaseClient } from '@supabase/supabase-js';
+import { makeAuth, type AuthOptions } from './auth.js';
+import { makeEntitiesProxy } from './entities.js';
+import { makeFunctions } from './functions.js';
+import { makeIntegrations, type IntegrationsOptions } from './integrations.js';
+import { app, makeAppLogs, makeUsers } from './misc.js';
+import { makeStorage } from './storage.js';
+import type { ClientOptions, EntitiesProxy } from './types.js';
+
+export type * from './types.js';
+export { defaultEntityToTable, resolveEntityMapping, parseOrderBy } from './entities.js';
+
+export interface ExtendedClientOptions extends ClientOptions {
+  /** Auth-related options (login redirect path, etc). */
+  authOptions?: AuthOptions;
+  /** Integration stub configuration (storage default bucket, edge function names). */
+  integrations?: Partial<IntegrationsOptions>;
+}
+
+export interface Base44Client {
+  /** Underlying Supabase client (anon key). */
+  supabase: SupabaseClient;
+  entities: EntitiesProxy;
+  auth: ReturnType<typeof makeAuth>;
+  functions: ReturnType<typeof makeFunctions>;
+  storage: ReturnType<typeof makeStorage>;
+  integrations: ReturnType<typeof makeIntegrations>;
+  /** Per-page activity logger. Writes to core.audit_log; errors are swallowed. */
+  appLogs: ReturnType<typeof makeAppLogs>;
+  /** Admin user management; browser-side calls throw (use Studio instead). */
+  users: ReturnType<typeof makeUsers>;
+  /** Empty placeholder for base44.app property access. */
+  app: Record<string, unknown>;
+  /** Service-role-scoped namespace for trusted server contexts. Throws if no service key supplied. */
+  asServiceRole: { entities: EntitiesProxy };
+}
+
+/** Create a Base44-compatible client backed by Supabase. */
+export function createClient(options: ExtendedClientOptions): Base44Client {
+  if (!options.supabaseUrl) throw new Error('createClient: supabaseUrl is required');
+  if (!options.supabaseAnonKey) throw new Error('createClient: supabaseAnonKey is required');
+  if (!options.schemaPrefix) throw new Error('createClient: schemaPrefix is required');
+
+  const supabase =
+    options.client ?? createSupabase(options.supabaseUrl, options.supabaseAnonKey);
+
+  const entities = makeEntitiesProxy(supabase, {
+    schemaPrefix: options.schemaPrefix,
+    sharedSchema: options.sharedSchema,
+    sharedEntities: options.sharedEntities,
+    entityMap: options.entityMap,
+  });
+
+  const asServiceRole = (() => {
+    let serviceClient: SupabaseClient | null = null;
+    let serviceEntities: EntitiesProxy | null = null;
+    return {
+      get entities(): EntitiesProxy {
+        if (!options.supabaseServiceRoleKey) {
+          throw new Error(
+            'asServiceRole.entities accessed but supabaseServiceRoleKey was not provided. ' +
+              'Only set this in trusted server contexts (edge functions, scripts).',
+          );
+        }
+        if (!serviceClient) {
+          serviceClient = createSupabase(options.supabaseUrl, options.supabaseServiceRoleKey);
+        }
+        if (!serviceEntities) {
+          serviceEntities = makeEntitiesProxy(serviceClient, {
+            schemaPrefix: options.schemaPrefix,
+            sharedSchema: options.sharedSchema,
+            sharedEntities: options.sharedEntities,
+            entityMap: options.entityMap,
+          });
+        }
+        return serviceEntities;
+      },
+    };
+  })();
+
+  return {
+    supabase,
+    entities,
+    auth: makeAuth(supabase, options.authOptions),
+    functions: makeFunctions(supabase),
+    storage: makeStorage(supabase, options.schemaPrefix),
+    integrations: makeIntegrations(supabase, {
+      defaultBucket: options.integrations?.defaultBucket ?? options.schemaPrefix,
+      sendEmailFunction: options.integrations?.sendEmailFunction,
+      invokeLlmFunction: options.integrations?.invokeLlmFunction,
+    }),
+    appLogs: makeAppLogs(supabase, options.schemaPrefix),
+    users: makeUsers(),
+    app,
+    asServiceRole,
+  };
+}

package/src/integrations.ts

@@ -0,0 +1,94 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+export interface IntegrationsOptions {
+  /** Default storage bucket for UploadFile. Falls back to schemaPrefix from createClient. */
+  defaultBucket: string;
+  /**
+   * Edge function name to invoke for SendEmail. If unset, calls fail loudly.
+   * Implement this function in supabase/volumes/functions/send-email/.
+   */
+  sendEmailFunction?: string;
+  /**
+   * Edge function name to invoke for InvokeLLM. If unset, calls fail loudly
+   * (AI features are out of scope for the air-gapped self-host stack).
+   */
+  invokeLlmFunction?: string;
+}
+
+/**
+ * Stub of `base44.integrations.Core.*`. Three methods are implemented:
+ *
+ *   UploadFile  → delegates to Supabase Storage upload + returns {url, path}.
+ *   SendEmail   → invokes a configured edge function (or throws if none).
+ *   InvokeLLM   → invokes a configured edge function (or throws if none).
+ *
+ * Air-gapped LAN cannot call OpenAI directly; wire your own LLM endpoint
+ * (Ollama, internal API gateway, etc.) inside an edge function and pass the
+ * function name via createClient({ integrations: { invokeLlmFunction: 'llm-relay' } }).
+ */
+export function makeIntegrations(client: SupabaseClient, opts: IntegrationsOptions) {
+  const Core = {
+    async UploadFile({
+      file,
+      bucket,
+      path,
+      contentType,
+    }: {
+      file: Blob | File | ArrayBuffer | Uint8Array;
+      bucket?: string;
+      path?: string;
+      contentType?: string;
+    }): Promise<{ url: string; path: string }> {
+      const b = bucket ?? opts.defaultBucket;
+      const p =
+        path ??
+        `uploads/${Date.now()}-${Math.random().toString(36).slice(2, 8)}-${(file as File)?.name ?? 'file'}`;
+      const { error } = await client.storage.from(b).upload(p, file, {
+        contentType: contentType ?? (file as File)?.type,
+        upsert: false,
+      });
+      if (error) throw error;
+      const { data } = client.storage.from(b).getPublicUrl(p);
+      return { url: data.publicUrl, path: p };
+    },
+
+    async SendEmail(payload: {
+      to: string | string[];
+      subject: string;
+      body?: string;
+      html?: string;
+      from?: string;
+    }): Promise<{ ok: boolean }> {
+      if (!opts.sendEmailFunction) {
+        throw new Error(
+          'SendEmail not configured. Set integrations.sendEmailFunction in createClient() ' +
+            'and deploy a corresponding Supabase Edge Function (e.g. send-email).',
+        );
+      }
+      const { error } = await client.functions.invoke(opts.sendEmailFunction, { body: payload });
+      if (error) throw error;
+      return { ok: true };
+    },
+
+    async InvokeLLM(payload: {
+      prompt: string;
+      model?: string;
+      [key: string]: unknown;
+    }): Promise<unknown> {
+      if (!opts.invokeLlmFunction) {
+        throw new Error(
+          'InvokeLLM not configured. AI features are disabled in this self-host build. ' +
+            'Set integrations.invokeLlmFunction in createClient() and deploy an edge function ' +
+            'that proxies to your LLM endpoint (Ollama / internal gateway).',
+        );
+      }
+      const { data, error } = await client.functions.invoke(opts.invokeLlmFunction, {
+        body: payload,
+      });
+      if (error) throw error;
+      return data;
+    },
+  };
+
+  return { Core };
+}

package/src/misc.ts

@@ -0,0 +1,43 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+/**
+ * Stub for `base44.appLogs` — Base44 cloud's per-page activity tracker.
+ * Writes a row to core.audit_log if the table exists, otherwise silently
+ * succeeds. App code wraps this in .catch(() => {}) anyway, so any failure
+ * is non-fatal.
+ */
+export function makeAppLogs(client: SupabaseClient, app: string) {
+  return {
+    async logUserInApp(pageName: string): Promise<void> {
+      try {
+        await client.schema('core' as never).from('audit_logs').insert({
+          app,
+          action: 'page_view',
+          module: pageName,
+        });
+      } catch {
+        // best-effort; analytics errors must never break the app
+      }
+    },
+  };
+}
+
+/**
+ * Stub for `base44.users` — admin-only user management. Self-host equivalent
+ * uses Supabase Auth admin API but requires a service_role key, which the
+ * browser client doesn't have. So inviteUser here logs a warning and returns
+ * a benign error so callers can show a "not supported" message.
+ */
+export function makeUsers() {
+  return {
+    async inviteUser(_args: { email: string; [key: string]: unknown }): Promise<never> {
+      throw new Error(
+        'inviteUser is admin-only and not exposed to the browser shim. ' +
+          'Use the Studio dashboard or an edge function with service_role to invite users.',
+      );
+    },
+  };
+}
+
+/** Empty placeholder for `base44.app` — kept defined so property access doesn't crash. */
+export const app: Record<string, unknown> = {};

package/src/server.ts

@@ -0,0 +1,54 @@
+import { createClient as createSupabase, type SupabaseClient } from '@supabase/supabase-js';
+import { makeEntitiesProxy } from './entities.js';
+import type { ClientOptions, EntitiesProxy } from './types.js';
+
+export type * from './types.js';
+
+export interface ServerClient {
+  supabase: SupabaseClient;
+  entities: EntitiesProxy;
+  asServiceRole: { entities: EntitiesProxy };
+}
+
+/**
+ * Create a Base44-style client from an incoming HTTP Request, intended for
+ * Supabase Edge Functions (Deno) or any server runtime that has fetch Request.
+ *
+ * Honors the caller's Authorization header so RLS applies as the end user.
+ * `asServiceRole` uses the configured service_role key (bypasses RLS) for
+ * privileged operations — analogous to base44.asServiceRole.
+ */
+export function createClientFromRequest(
+  req: Request,
+  options: Omit<ClientOptions, 'client'> & { supabaseServiceRoleKey: string },
+): ServerClient {
+  if (!options.supabaseUrl) throw new Error('createClientFromRequest: supabaseUrl is required');
+  if (!options.supabaseAnonKey)
+    throw new Error('createClientFromRequest: supabaseAnonKey is required');
+  if (!options.supabaseServiceRoleKey)
+    throw new Error('createClientFromRequest: supabaseServiceRoleKey is required for server use');
+
+  const authHeader = req.headers.get('Authorization') ?? '';
+  const userClient = createSupabase(options.supabaseUrl, options.supabaseAnonKey, {
+    global: { headers: { Authorization: authHeader } },
+    auth: { persistSession: false, autoRefreshToken: false },
+  });
+  const serviceClient = createSupabase(options.supabaseUrl, options.supabaseServiceRoleKey, {
+    auth: { persistSession: false, autoRefreshToken: false },
+  });
+
+  const mappingOpts = {
+    schemaPrefix: options.schemaPrefix,
+    sharedSchema: options.sharedSchema,
+    sharedEntities: options.sharedEntities,
+    entityMap: options.entityMap,
+  };
+
+  return {
+    supabase: userClient,
+    entities: makeEntitiesProxy(userClient, mappingOpts),
+    asServiceRole: {
+      entities: makeEntitiesProxy(serviceClient, mappingOpts),
+    },
+  };
+}

package/src/storage.ts

@@ -0,0 +1,63 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+export interface UploadFileArgs {
+  /** Supabase Storage bucket name. Defaults to schemaPrefix from client options. */
+  bucket?: string;
+  /** Object path within the bucket (e.g. 'invoices/2026/inv-001.pdf'). */
+  path: string;
+  /** File contents. */
+  file: Blob | File | ArrayBuffer | Uint8Array;
+  /** Content-Type. Inferred from File if omitted. */
+  contentType?: string;
+  /** Overwrite existing object at path. Default false. */
+  upsert?: boolean;
+}
+
+export function makeStorage(client: SupabaseClient, defaultBucket: string) {
+  return {
+    /** Upload a file to a bucket. Returns the public URL. */
+    async uploadFile({
+      bucket,
+      path,
+      file,
+      contentType,
+      upsert = false,
+    }: UploadFileArgs): Promise<{ path: string; url: string }> {
+      const b = bucket ?? defaultBucket;
+      const { error } = await client.storage.from(b).upload(path, file, {
+        contentType,
+        upsert,
+      });
+      if (error) throw error;
+      const { data } = client.storage.from(b).getPublicUrl(path);
+      return { path, url: data.publicUrl };
+    },
+    /** Get a public URL for a stored object. */
+    getPublicUrl(path: string, bucket?: string): string {
+      const b = bucket ?? defaultBucket;
+      const { data } = client.storage.from(b).getPublicUrl(path);
+      return data.publicUrl;
+    },
+    /** Generate a time-limited signed URL for private buckets. */
+    async createSignedUrl(path: string, expiresInSec = 3600, bucket?: string): Promise<string> {
+      const b = bucket ?? defaultBucket;
+      const { data, error } = await client.storage.from(b).createSignedUrl(path, expiresInSec);
+      if (error) throw error;
+      return data.signedUrl;
+    },
+    /** Delete one or more objects. */
+    async remove(paths: string | string[], bucket?: string): Promise<void> {
+      const b = bucket ?? defaultBucket;
+      const list = Array.isArray(paths) ? paths : [paths];
+      const { error } = await client.storage.from(b).remove(list);
+      if (error) throw error;
+    },
+    /** List objects in a bucket prefix. */
+    async list(prefix?: string, bucket?: string) {
+      const b = bucket ?? defaultBucket;
+      const { data, error } = await client.storage.from(b).list(prefix);
+      if (error) throw error;
+      return data ?? [];
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,110 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+export type Json = string | number | boolean | null | Json[] | { [key: string]: Json };
+
+export interface EntityMapping {
+  schema: string;
+  table: string;
+}
+
+export 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;
+}
+
+export 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.
+ */
+export type MongoFilter = {
+  $eq?: unknown; $ne?: unknown;
+  $gt?: unknown; $gte?: unknown; $lt?: unknown; $lte?: unknown;
+  $in?: unknown[]; $nin?: unknown[];
+  $like?: string; $ilike?: string;
+};
+
+export type FilterValue =
+  | string
+  | number
+  | boolean
+  | null
+  | string[]
+  | number[]
+  | MongoFilter
+  | { op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'in'; value: unknown };
+
+export type FilterObject = Record<string, FilterValue>;
+
+export 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;
+}
+
+export type EntitiesProxy = {
+  [entityName: string]: EntityApi;
+};