@fayz-ai/core 0.1.6

package/dist/chunk-YSBXGHAM.js

@@ -0,0 +1,643 @@
+// src/data/supabase.ts
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+}
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function mapRow(row, columnMap) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    const camelKey = columnMap?.[key] ?? snakeToCamel(key);
+    result[camelKey] = value;
+  }
+  return result;
+}
+function mapEntity(entity, columnMap) {
+  const reverseMap = {};
+  if (columnMap) {
+    for (const [snake, camel] of Object.entries(columnMap)) {
+      reverseMap[camel] = snake;
+    }
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(entity)) {
+    if (key === "id" || key === "createdAt" || key === "updatedAt" || key === "tenantId") continue;
+    const snakeKey = reverseMap[key] ?? camelToSnake(key);
+    result[snakeKey] = value;
+  }
+  return result;
+}
+var _globalSupabaseClient = null;
+function setGlobalSupabaseClient(client) {
+  _globalSupabaseClient = client;
+}
+function getSupabaseClientOptional() {
+  return _globalSupabaseClient;
+}
+function createSupabaseProvider(table, config) {
+  const schema = config?.schema ?? "public";
+  const tenantIdCol = config?.tenantIdColumn ?? "tenant_id";
+  const searchCols = config?.searchColumns ?? [];
+  const selectCols = config?.selectColumns ?? "*";
+  const columnMap = config?.columnMap;
+  function resolveTenantId2() {
+    if (!config?.tenantId) return void 0;
+    return typeof config.tenantId === "function" ? config.tenantId() : config.tenantId;
+  }
+  function getClient() {
+    const supabase = config?.supabaseClient ?? _globalSupabaseClient;
+    if (!supabase) throw new Error(`[@fayz-ai/core] Supabase client not available. Call createFayzApp with a provider first.`);
+    return schema === "public" ? supabase : supabase.schema(schema);
+  }
+  return {
+    async list(query) {
+      let q = getClient().from(table).select(selectCols, { count: "exact" });
+      const tenantId = resolveTenantId2();
+      if (tenantId) q = q.eq(tenantIdCol, tenantId);
+      if (config?.filters) {
+        for (const [col, val] of Object.entries(config.filters)) {
+          q = q.eq(col, val);
+        }
+      }
+      if (query.filters) {
+        for (const [key, val] of Object.entries(query.filters)) {
+          if (val == null || val === "") continue;
+          const col = columnMap?.[key] ?? camelToSnake(key);
+          q = q.eq(col, val);
+        }
+      }
+      if (query.search && searchCols.length > 0) {
+        const term = `%${query.search}%`;
+        const orClause = searchCols.map((col) => `${camelToSnake(col)}.ilike.${term}`).join(",");
+        q = q.or(orClause);
+      }
+      if (query.sortBy) {
+        q = q.order(camelToSnake(query.sortBy), { ascending: query.sortDir !== "desc" });
+      } else {
+        q = q.order("created_at", { ascending: false });
+      }
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const from = (page - 1) * pageSize;
+      q = q.range(from, from + pageSize - 1);
+      const { data, error, count } = await q;
+      if (error) throw error;
+      return {
+        data: (data ?? []).map((row) => mapRow(row, columnMap)),
+        total: count ?? 0
+      };
+    },
+    async create(data) {
+      const row = mapEntity(data, columnMap);
+      const tenantId = resolveTenantId2();
+      if (tenantId) row[tenantIdCol] = tenantId;
+      if (config?.defaults) {
+        for (const [col, val] of Object.entries(config.defaults)) {
+          if (row[col] === void 0) row[col] = val;
+        }
+      }
+      const { data: created, error } = await getClient().from(table).insert(row).select().single();
+      if (error) throw error;
+      return mapRow(created, columnMap);
+    },
+    async update(id, data) {
+      const row = mapEntity(data, columnMap);
+      const { data: updated, error } = await getClient().from(table).update(row).eq("id", id).select().single();
+      if (error) throw error;
+      return mapRow(updated, columnMap);
+    },
+    async remove(id) {
+      const { error } = await getClient().from(table).delete().eq("id", id);
+      if (error) throw error;
+    }
+  };
+}
+
+// src/data/fayz-api.ts
+function resolveTenantId(config) {
+  const tenantId = config?.tenantId;
+  return typeof tenantId === "function" ? tenantId() : tenantId;
+}
+async function resolveRuntimeToken(config) {
+  const runtimeToken = config?.runtimeToken;
+  return typeof runtimeToken === "function" ? runtimeToken() : runtimeToken;
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function appendQuery(url, query, tenantId, tenantIdColumn = "tenant_id", searchColumns = []) {
+  const filters = normalizeFilters(query.filters);
+  if (query.search && searchColumns[0]) {
+    filters.push({ column: searchColumns[0], operator: "ilike", value: `%${query.search}%` });
+  }
+  if (query.sortBy) url.searchParams.set("sortColumn", query.sortBy);
+  if (query.sortDir) url.searchParams.set("sortDirection", query.sortDir);
+  if (query.page != null) url.searchParams.set("page", String(query.page));
+  if (query.pageSize != null) url.searchParams.set("limit", String(query.pageSize));
+  if (tenantId) filters.push({ column: tenantIdColumn, operator: "eq", value: tenantId });
+  if (filters.length > 0) url.searchParams.set("filters", JSON.stringify(filters));
+}
+async function parseResponse(response) {
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`[@fayz-ai/core] Fayz API request failed (${response.status}): ${text || response.statusText}`);
+  }
+  return response.json();
+}
+function isFilterOperator(value) {
+  return typeof value === "string" && [
+    "eq",
+    "neq",
+    "gt",
+    "lt",
+    "gte",
+    "lte",
+    "like",
+    "ilike",
+    "is_null",
+    "is_not_null"
+  ].includes(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeFilters(filters) {
+  if (!filters) return [];
+  return Object.entries(filters).map(([column, raw]) => {
+    if (isRecord(raw) && isFilterOperator(raw.operator)) {
+      return { column, operator: raw.operator, value: raw.value };
+    }
+    return { column, operator: "eq", value: raw };
+  });
+}
+function createFayzApiProvider(entityOrTable, config = {}) {
+  const fetcher = config.fetcher ?? fetch;
+  const baseUrl = trimTrailingSlash(config.baseUrl ?? "");
+  const projectId = config.projectId;
+  const table = config.table ?? entityOrTable;
+  const idColumn = config.idColumn ?? "id";
+  async function headers(runtimeToken) {
+    return {
+      "Content-Type": "application/json",
+      ...config.headers ? await config.headers() : {},
+      ...runtimeToken ? { Authorization: `Bearer ${runtimeToken}` } : {}
+    };
+  }
+  function tableRowsUrl(runtime = false) {
+    const prefix = baseUrl || (typeof window !== "undefined" ? window.location.origin : "http://localhost");
+    const encodedProjectId = encodeURIComponent(projectId ?? "current");
+    const encodedTable = encodeURIComponent(table);
+    const route = runtime ? `/api/v1/runtime/projects/${encodedProjectId}/database/tables/${encodedTable}/rows` : `/api/projects/${encodedProjectId}/database/tables/${encodedTable}/rows`;
+    const url = new URL(route, prefix);
+    if (config.schema) url.searchParams.set("schema", config.schema);
+    return url;
+  }
+  function withTenant(data, runtime = false) {
+    if (runtime) return data;
+    const tenantId = resolveTenantId(config);
+    if (!tenantId || config.tenantIdColumn === false) return data;
+    return { ...data, [config.tenantIdColumn ?? "tenant_id"]: tenantId };
+  }
+  function primaryKeys(id) {
+    return { [idColumn]: id };
+  }
+  async function listRows(query) {
+    const runtimeToken = await resolveRuntimeToken(config);
+    const runtime = Boolean(runtimeToken);
+    const url = tableRowsUrl(runtime);
+    appendQuery(
+      url,
+      query,
+      runtime || config.tenantIdColumn === false ? void 0 : resolveTenantId(config),
+      config.tenantIdColumn || void 0,
+      config.searchColumns
+    );
+    const result = await parseResponse(await fetcher(url, { headers: await headers(runtimeToken) }));
+    return { data: result.rows, total: result.total };
+  }
+  async function assertTenantScopedRowExists(id, runtime = false) {
+    if (runtime) return;
+    const tenantId = config.tenantIdColumn === false ? void 0 : resolveTenantId(config);
+    if (!tenantId) return;
+    const result = await listRows({ filters: { [idColumn]: id }, page: 1, pageSize: 1 });
+    if (result.data.length === 0) {
+      throw new Error(`[@fayz-ai/core] Row "${id}" was not found for the active tenant.`);
+    }
+  }
+  return {
+    async list(query) {
+      return listRows(query);
+    },
+    async create(data) {
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      return parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "POST",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify(withTenant(data, runtime))
+      }));
+    },
+    async update(id, data) {
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      await assertTenantScopedRowExists(id, runtime);
+      return parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "PATCH",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify({ primaryKeys: primaryKeys(id), data })
+      }));
+    },
+    async remove(id) {
+      const runtimeToken = await resolveRuntimeToken(config);
+      const runtime = Boolean(runtimeToken);
+      await assertTenantScopedRowExists(id, runtime);
+      await parseResponse(await fetcher(tableRowsUrl(runtime), {
+        method: "DELETE",
+        headers: await headers(runtimeToken),
+        body: JSON.stringify({ rows: [primaryKeys(id)] })
+      }));
+    }
+  };
+}
+
+// src/data/mock.ts
+function createMockProvider(entityDefOrSearchKeys, initialData = []) {
+  let items = [...initialData];
+  const searchableKeys = Array.isArray(entityDefOrSearchKeys) ? entityDefOrSearchKeys : entityDefOrSearchKeys.fields.filter((f) => f.searchable).map((f) => f.key);
+  const defaultSort = Array.isArray(entityDefOrSearchKeys) ? void 0 : entityDefOrSearchKeys.defaultSort;
+  const defaultSortDir = Array.isArray(entityDefOrSearchKeys) ? "asc" : entityDefOrSearchKeys.defaultSortDir ?? "asc";
+  return {
+    async list(query) {
+      let filtered = [...items];
+      if (query.search && searchableKeys.length > 0) {
+        const term = query.search.toLowerCase();
+        filtered = filtered.filter(
+          (item) => searchableKeys.some((key) => {
+            const val = item[key];
+            return typeof val === "string" && val.toLowerCase().includes(term);
+          })
+        );
+      }
+      if (query.filters) {
+        for (const [key, val] of Object.entries(query.filters)) {
+          if (val == null || val === "") continue;
+          filtered = filtered.filter((item) => item[key] === val);
+        }
+      }
+      const sortBy = query.sortBy ?? defaultSort;
+      const sortDir = query.sortDir ?? defaultSortDir;
+      if (sortBy) {
+        filtered.sort((a, b) => {
+          const av = a[sortBy] ?? "";
+          const bv = b[sortBy] ?? "";
+          const cmp = typeof av === "number" && typeof bv === "number" ? av - bv : String(av).localeCompare(String(bv));
+          return sortDir === "desc" ? -cmp : cmp;
+        });
+      }
+      const total = filtered.length;
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const start = (page - 1) * pageSize;
+      const data = filtered.slice(start, start + pageSize);
+      return { data, total };
+    },
+    async create(data) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const item = {
+        ...data,
+        id: crypto.randomUUID(),
+        tenantId: "mock-tenant",
+        createdAt: now,
+        updatedAt: now
+      };
+      items.unshift(item);
+      return item;
+    },
+    async update(id, data) {
+      const idx = items.findIndex((i) => i.id === id);
+      if (idx === -1) throw new Error(`[@fayz-ai/core] Mock provider: item not found: ${id}`);
+      items[idx] = { ...items[idx], ...data, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      return items[idx];
+    },
+    async remove(id) {
+      items = items.filter((i) => i.id !== id);
+    }
+  };
+}
+
+// src/data/archetype.ts
+var HAS_KIND = /* @__PURE__ */ new Set(["person", "category", "order", "transaction", "schedule", "location"]);
+var ARCHETYPE_CONFIG = {
+  person: { table: "persons", fkColumn: "person_id" },
+  category: { table: "categories", fkColumn: "category_id" },
+  product: { table: "products", fkColumn: "product_id" },
+  service: { table: "services", fkColumn: "service_id" },
+  location: { table: "locations", fkColumn: "location_id" },
+  order: { table: "orders", fkColumn: "order_id" },
+  transaction: { table: "transactions", fkColumn: "transaction_id" },
+  schedule: { table: "schedules", fkColumn: "schedule_id" }
+};
+var ARCHETYPE_COLUMNS = {
+  person: /* @__PURE__ */ new Set(["name", "email", "phone", "document_number", "avatar_url", "date_of_birth", "address", "city", "state", "country", "postal_code", "tags", "is_active", "notes", "metadata"]),
+  category: /* @__PURE__ */ new Set(["name", "slug", "parent_id", "icon", "color", "sort_order", "is_active", "metadata"]),
+  product: /* @__PURE__ */ new Set(["name", "description", "sku", "price", "cost", "currency", "unit", "image_url", "stock", "min_stock", "status", "is_active", "tags", "metadata", "category_id"]),
+  service: /* @__PURE__ */ new Set(["name", "description", "price", "cost", "currency", "duration_minutes", "image_url", "status", "is_active", "tags", "metadata", "category_id"]),
+  location: /* @__PURE__ */ new Set(["name", "email", "phone", "address", "city", "state", "country", "postal_code", "is_headquarters", "is_active", "tags", "notes", "metadata"]),
+  order: /* @__PURE__ */ new Set(["reference_number", "status", "party_id", "assignee_id", "location_id", "subtotal", "discount", "tax", "total", "currency", "due_at", "completed_at", "notes", "tags", "metadata"]),
+  transaction: /* @__PURE__ */ new Set(["order_id", "party_id", "amount", "currency", "payment_method", "reference", "status", "transacted_at", "notes", "metadata"]),
+  schedule: /* @__PURE__ */ new Set(["assignee_id", "location_id", "day_of_week", "specific_date", "starts_at", "ends_at", "is_active", "metadata"])
+};
+function camelToSnake2(str) {
+  return str.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+}
+function snakeToCamel2(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function mapRow2(row) {
+  const result = {};
+  for (const [key, value] of Object.entries(row)) {
+    result[snakeToCamel2(key)] = value;
+  }
+  return result;
+}
+function createArchetypeProvider(config) {
+  const ac = ARCHETYPE_CONFIG[config.archetype];
+  const archetypeColumns = ARCHETYPE_COLUMNS[config.archetype];
+  const { fkColumn } = ac;
+  function getClient() {
+    const supabase = getSupabaseClientOptional();
+    if (!supabase) throw new Error("Supabase client not available");
+    return supabase;
+  }
+  function coreClient() {
+    return getClient().schema("saas_core");
+  }
+  function splitFields(data) {
+    const archetypeData = {};
+    const projectData = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (["id", "createdAt", "updatedAt", "tenantId", fkColumn].includes(key)) continue;
+      const snakeKey = camelToSnake2(key);
+      if (archetypeColumns.has(snakeKey)) {
+        archetypeData[snakeKey] = value;
+      } else {
+        projectData[snakeKey] = value;
+      }
+    }
+    return { archetypeData, projectData };
+  }
+  const VIEW_MAP = {
+    clients: "v_clients",
+    staff_members: "v_staff"
+  };
+  const viewName = VIEW_MAP[config.projectTable] ?? `v_${config.projectTable}`;
+  return {
+    async list(query) {
+      const tenantId = config.tenantId();
+      if (!tenantId) return { data: [], total: 0 };
+      let q = getClient().from(viewName).select("*", { count: "exact" }).eq("tenant_id", tenantId);
+      if (query.search && config.searchColumns && config.searchColumns.length > 0) {
+        const term = `%${query.search}%`;
+        const orClauses = config.searchColumns.map((col) => camelToSnake2(col)).map((col) => `${col}.ilike.${term}`);
+        if (orClauses.length > 0) {
+          q = q.or(orClauses.join(","));
+        }
+      }
+      if (query.sortBy) {
+        q = q.order(camelToSnake2(query.sortBy), { ascending: query.sortDir !== "desc" });
+      } else {
+        q = q.order("created_at", { ascending: false });
+      }
+      const page = query.page ?? 1;
+      const pageSize = query.pageSize ?? 50;
+      const from = (page - 1) * pageSize;
+      q = q.range(from, from + pageSize - 1);
+      const { data, error, count } = await q;
+      if (error) throw error;
+      const rows = (data ?? []).map((row) => mapRow2(row));
+      return { data: rows, total: count ?? 0 };
+    },
+    async create(data) {
+      const tenantId = config.tenantId();
+      if (!tenantId) throw new Error("No tenant selected");
+      const { archetypeData, projectData } = splitFields(data);
+      archetypeData.tenant_id = tenantId;
+      if (HAS_KIND.has(config.archetype)) {
+        archetypeData.kind = config.archetypeKind;
+      }
+      const { data: archetypeRow, error: archetypeError } = await coreClient().from(ac.table).insert(archetypeData).select().single();
+      if (archetypeError) throw archetypeError;
+      const archetypeId = archetypeRow.id;
+      projectData[fkColumn] = archetypeId;
+      projectData.tenant_id = tenantId;
+      const { error: projectError } = await getClient().from(config.projectTable).insert(projectData);
+      if (projectError) {
+        await coreClient().from(ac.table).delete().eq("id", archetypeId);
+        throw projectError;
+      }
+      return { id: archetypeId, ...archetypeRow, ...projectData };
+    },
+    async update(id, data) {
+      const { archetypeData, projectData } = splitFields(data);
+      if (Object.keys(archetypeData).length > 0) {
+        const { error } = await coreClient().from(ac.table).update(archetypeData).eq("id", id);
+        if (error) throw error;
+      }
+      if (Object.keys(projectData).length > 0) {
+        const { error } = await getClient().from(config.projectTable).update(projectData).eq(fkColumn, id);
+        if (error) throw error;
+      }
+      const { data: archetypeRow } = await coreClient().from(ac.table).select("*").eq("id", id).single();
+      const { data: projectRow } = await getClient().from(config.projectTable).select("*").eq(fkColumn, id).single();
+      const flat = { ...archetypeRow, ...projectRow, id };
+      delete flat[fkColumn];
+      return mapRow2(flat);
+    },
+    async remove(id) {
+      const { error } = await coreClient().from(ac.table).delete().eq("id", id);
+      if (error) throw error;
+    }
+  };
+}
+
+// src/lib/cache.ts
+function sortDeep(value) {
+  if (value === null || value === void 0 || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(sortDeep);
+  const sorted = {};
+  for (const k of Object.keys(value).sort()) {
+    sorted[k] = sortDeep(value[k]);
+  }
+  return sorted;
+}
+function stableKey(...parts) {
+  return parts.map((p) => typeof p === "string" ? p : JSON.stringify(sortDeep(p))).join(":");
+}
+function createCacheStore(config) {
+  const defaultTTL = config?.defaultTTL ?? 6e4;
+  const maxEntries = config?.maxEntries ?? 500;
+  const entries = /* @__PURE__ */ new Map();
+  function evictLRU() {
+    if (entries.size <= maxEntries) return;
+    let oldestKey = null;
+    let oldestAccess = Infinity;
+    for (const [key, entry] of entries) {
+      if (entry.lastAccess < oldestAccess) {
+        oldestAccess = entry.lastAccess;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) entries.delete(oldestKey);
+  }
+  return {
+    get(key) {
+      const entry = entries.get(key);
+      if (!entry) return void 0;
+      if (Date.now() > entry.expiresAt) {
+        entries.delete(key);
+        return void 0;
+      }
+      entry.lastAccess = Date.now();
+      return entry.data;
+    },
+    set(key, data, ttl) {
+      const now = Date.now();
+      entries.set(key, {
+        data,
+        expiresAt: now + (ttl ?? defaultTTL),
+        lastAccess: now
+      });
+      evictLRU();
+    },
+    invalidate(prefix) {
+      for (const key of entries.keys()) {
+        if (key.startsWith(prefix)) {
+          entries.delete(key);
+        }
+      }
+    },
+    clear() {
+      entries.clear();
+    },
+    size() {
+      return entries.size;
+    }
+  };
+}
+var globalCache = createCacheStore();
+function clearGlobalCache() {
+  globalCache.clear();
+}
+
+// src/data/cached.ts
+function withCache(provider, options) {
+  function prefix() {
+    return `${options.tenantId() ?? "_"}:${options.table}`;
+  }
+  return {
+    async list(query) {
+      const key = `${prefix()}:${stableKey(query)}`;
+      const cached = globalCache.get(key);
+      if (cached) return cached;
+      const result = await provider.list(query);
+      globalCache.set(key, result, options.ttl);
+      return result;
+    },
+    async create(data) {
+      const result = await provider.create(data);
+      globalCache.invalidate(prefix());
+      return result;
+    },
+    async update(id, data) {
+      const result = await provider.update(id, data);
+      globalCache.invalidate(prefix());
+      return result;
+    },
+    async remove(id) {
+      await provider.remove(id);
+      globalCache.invalidate(prefix());
+    }
+  };
+}
+
+// src/tenant/index.ts
+var _activeTenantId;
+function setActiveTenantId(id) {
+  if (id !== _activeTenantId) {
+    _activeTenantId = id;
+    clearGlobalCache();
+  }
+}
+function getActiveTenantId() {
+  return _activeTenantId;
+}
+
+// src/data/resolve.ts
+function resolveDataProvider(entityDef, mockData, options = {}) {
+  const backend = options.backend;
+  if (backend?.provider === "mock") {
+    return createMockProvider(entityDef, mockData);
+  }
+  if (backend?.provider === "fayz-api") {
+    const table = entityDef.data?.table ?? entityDef.name;
+    return createFayzApiProvider(table, {
+      ...options.fayzApi,
+      baseUrl: options.fayzApi?.baseUrl ?? backend.url,
+      projectId: options.fayzApi?.projectId ?? backend.projectRef,
+      entityKey: entityDef.name ?? table,
+      table,
+      schema: options.fayzApi?.schema ?? entityDef.data?.schema,
+      idColumn: options.fayzApi?.idColumn ?? entityDef.data?.columnMap?.id,
+      searchColumns: options.fayzApi?.searchColumns ?? entityDef.data?.searchColumns ?? entityDef.fields.filter((field) => field.searchable).map((field) => field.key),
+      tenantIdColumn: entityDef.data?.tenantScoped === false ? false : options.fayzApi?.tenantIdColumn ?? entityDef.data?.tenantIdColumn,
+      tenantId: options.fayzApi?.tenantId ?? (() => getActiveTenantId())
+    });
+  }
+  if (backend?.provider === "custom") {
+    const adapterId = backend.adapterId;
+    const factory = adapterId ? options.customProviders?.[adapterId] : void 0;
+    if (!adapterId || !factory) {
+      throw new Error(`[@fayz-ai/core] Custom data provider "${adapterId ?? "unknown"}" is not registered.`);
+    }
+    return factory(entityDef, mockData);
+  }
+  const client = getSupabaseClientOptional();
+  if (client && entityDef.data?.table) {
+    const tenantId = () => getActiveTenantId();
+    const cacheOptions = {
+      table: entityDef.data.table,
+      tenantId,
+      ttl: entityDef.data.cacheTTL
+    };
+    if (entityDef.data.archetype && entityDef.data.archetypeKind && !entityDef.data.schema) {
+      return withCache(createArchetypeProvider({
+        archetype: entityDef.data.archetype,
+        archetypeKind: entityDef.data.archetypeKind,
+        projectTable: entityDef.data.table,
+        tenantId,
+        searchColumns: entityDef.data.searchColumns ?? entityDef.fields.filter((field) => field.searchable).map((field) => field.key)
+      }), cacheOptions);
+    }
+    return withCache(createSupabaseProvider(entityDef.data.table, {
+      schema: entityDef.data.schema,
+      tenantId: entityDef.data.tenantScoped === false ? void 0 : tenantId,
+      tenantIdColumn: entityDef.data.tenantIdColumn,
+      searchColumns: entityDef.data.searchColumns ?? entityDef.fields.filter((field) => field.searchable).map((field) => field.key),
+      selectColumns: entityDef.data.selectColumns,
+      columnMap: entityDef.data.columnMap,
+      filters: entityDef.data.filters,
+      defaults: entityDef.data.defaults
+    }), cacheOptions);
+  }
+  if (entityDef.data?.table) {
+    console.warn(
+      `[fayz/core] resolveDataProvider: falling back to mock for "${entityDef.name}" (table: ${entityDef.data.table}). Supabase client ${client ? "available" : "NOT initialized"}.`
+    );
+  }
+  return createMockProvider(entityDef, mockData);
+}
+
+export { clearGlobalCache, createArchetypeProvider, createCacheStore, createFayzApiProvider, createMockProvider, createSupabaseProvider, getActiveTenantId, getSupabaseClientOptional, globalCache, resolveDataProvider, setActiveTenantId, setGlobalSupabaseClient, stableKey, withCache };
+//# sourceMappingURL=chunk-YSBXGHAM.js.map
+//# sourceMappingURL=chunk-YSBXGHAM.js.map