@promakeai/dbreact 1.0.4 → 1.0.5

package/README.md

@@ -622,10 +622,14 @@ await adapter.create('products', newProduct);
 
 ---
 
-## Troubleshooting
-
-**"useDbLang must be used within a DbProvider"**
-- Ensure component is wrapped in DbProvider
+## Troubleshooting
+
+**Production crash: `jsxDEV is not a function`**
+- Run `bun run test:build-runtime` before publishing.
+- This verifies `dist/index.js` does not include `react/jsx-dev-runtime`.
+
+**"useDbLang must be used within a DbProvider"**
+- Ensure component is wrapped in DbProvider
 
 **Queries return empty results**
 - Check adapter is connected: `const { isConnected } = useDb()`

package/dist/adapters/SqliteAdapter.js

@@ -21,6 +21,7 @@ import { buildWhereClause, buildTranslationQuery, buildTranslationQueryById, bui
 export class SqliteAdapter {
     db = null;
     SQL = null;
+    tableColumnsCache = new Map();
     config;
     schema;
     defaultLang;
@@ -39,6 +40,7 @@ export class SqliteAdapter {
     setSchema(schema) {
         this.schema = schema;
         this.config.schema = schema;
+        this.tableColumnsCache.clear();
     }
     async connect() {
         // Initialize sql.js
@@ -162,6 +164,7 @@ export class SqliteAdapter {
             schema: this.schema,
             lang: options.lang,
             fallbackLang: options.fallbackLang ?? this.defaultLang,
+            mainFallbackFields: await this.getAvailableMainFallbackFields(table),
             where: options.where,
             orderBy: options.orderBy,
             limit: options.limit,
@@ -195,7 +198,7 @@ export class SqliteAdapter {
             const results = await this.list(table, { where: { id }, limit: 1 });
             return results[0] ?? null;
         }
-        const { sql, params } = buildTranslationQueryById(table, this.schema, id, options.lang, options.fallbackLang ?? this.defaultLang);
+        const { sql, params } = buildTranslationQueryById(table, this.schema, id, options.lang, options.fallbackLang ?? this.defaultLang, await this.getAvailableMainFallbackFields(table));
         const rows = this.runQuery(sql, params);
         const deserialized = this.deserializeResults(table, rows);
         return deserialized[0] ?? null;
@@ -449,6 +452,7 @@ export class SqliteAdapter {
             this.persist();
             this.db.close();
             this.db = null;
+            this.tableColumnsCache.clear();
         }
     }
     // Transaction methods
@@ -495,6 +499,25 @@ export class SqliteAdapter {
         this.persist();
         return { created: ids.length, ids };
     }
+    async getAvailableMainFallbackFields(table) {
+        const tableSchema = this.schema?.tables[table];
+        if (!tableSchema)
+            return [];
+        const translatableFields = getTranslatableFields(tableSchema);
+        if (translatableFields.length === 0)
+            return [];
+        const tableColumns = await this.getTableColumns(table);
+        return translatableFields.filter((field) => tableColumns.has(field));
+    }
+    async getTableColumns(table) {
+        const cached = this.tableColumnsCache.get(table);
+        if (cached)
+            return cached;
+        const schema = await this.getTableSchema(table);
+        const columnSet = new Set(schema.map((col) => col.name));
+        this.tableColumnsCache.set(table, columnSet);
+        return columnSet;
+    }
     async updateMany(table, updates) {
         let updated = 0;
         for (const { id, data } of updates) {

package/dist/hooks/useDbHooks.js

@@ -21,7 +21,8 @@
  * ```
  */
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { useAdapter, useDbLang } from "../providers/DbProvider";
+import { useAdapter, useDb, useDbLang } from "../providers/DbProvider";
+import { resolvePopulate } from "@promakeai/orm";
 /**
  * Hook to list all records from a table
  *
@@ -40,14 +41,25 @@ import { useAdapter, useDbLang } from "../providers/DbProvider";
  */
 export function useDbList(table, options) {
     const adapter = useAdapter();
+    const { schema } = useDb();
     const { lang, fallbackLang } = useDbLang();
+    const { populate, ...queryOpts } = options || {};
     return useQuery({
-        queryKey: [table, "list", options, lang],
-        queryFn: () => adapter.list(table, {
-            ...options,
-            lang,
-            fallbackLang,
-        }),
+        queryKey: [table, "list", queryOpts, lang, populate],
+        queryFn: async () => {
+            const records = await adapter.list(table, {
+                ...queryOpts,
+                lang,
+                fallbackLang,
+            });
+            if (populate && schema) {
+                const adapterWrapper = {
+                    findMany: (t, opts) => adapter.list(t, { ...opts, lang, fallbackLang }),
+                };
+                return resolvePopulate(records, table, populate, schema, adapterWrapper);
+            }
+            return records;
+        },
         enabled: options?.enabled ?? true,
     });
 }
@@ -73,15 +85,27 @@ export function useDbList(table, options) {
  */
 export function useDbGet(table, idOrOptions, maybeOptions) {
     const adapter = useAdapter();
+    const { schema } = useDb();
     const { lang, fallbackLang } = useDbLang();
     const isWhereMode = typeof idOrOptions === "object" && idOrOptions !== null && "where" in idOrOptions;
     const where = isWhereMode ? idOrOptions.where : { id: idOrOptions };
     const enabled = isWhereMode
         ? (idOrOptions.enabled ?? true)
         : ((maybeOptions?.enabled ?? true) && idOrOptions !== undefined);
+    const populate = isWhereMode ? idOrOptions.populate : maybeOptions?.populate;
     return useQuery({
-        queryKey: [table, "single", where, lang],
-        queryFn: () => adapter.findOne(table, { where, lang, fallbackLang }),
+        queryKey: [table, "single", where, lang, populate],
+        queryFn: async () => {
+            const record = await adapter.findOne(table, { where, lang, fallbackLang });
+            if (record && populate && schema) {
+                const adapterWrapper = {
+                    findMany: (t, opts) => adapter.list(t, { ...opts, lang, fallbackLang }),
+                };
+                const [populated] = await resolvePopulate([record], table, populate, schema, adapterWrapper);
+                return populated;
+            }
+            return record;
+        },
         enabled,
     });
 }

package/dist/index.js

@@ -1,697 +1,14 @@
-// index.ts
-import {
-  ORM,
-  defineSchema,
-  f,
-  buildWhereClause as buildWhereClause2,
-  resolvePopulate as resolvePopulate2,
-  getPopulatableFields,
-  validatePopulate,
-  parseJSONSchema
-} from "@promakeai/orm";
-
-// providers/DbProvider.tsx
-import {
-  createContext,
-  useContext,
-  useState,
-  useEffect,
-  useMemo,
-  useCallback,
-  useRef
-} from "react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { jsxDEV } from "react/jsx-dev-runtime";
-var DbContext = createContext(null);
-var DbLangContext = createContext(null);
-var defaultQueryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 1000 * 60 * 5,
-      gcTime: 1000 * 60 * 30,
-      refetchOnWindowFocus: false
-    }
-  }
-});
-function DbProvider({
-  adapter,
-  schema,
-  lang: langProp = "en",
-  fallbackLang = "en",
-  autoConnect = true,
-  queryClient = defaultQueryClient,
-  children
-}) {
-  const [isConnected, setIsConnected] = useState(false);
-  const [error, setError] = useState(null);
-  const [lang, setLangState] = useState(langProp);
-  const isFirstRender = useRef(true);
-  useEffect(() => {
-    if (langProp !== lang) {
-      setLangState(langProp);
-    }
-  }, [langProp]);
-  useEffect(() => {
-    if (isFirstRender.current) {
-      isFirstRender.current = false;
-      return;
-    }
-    queryClient.invalidateQueries();
-  }, [lang]);
-  useEffect(() => {
-    if (!autoConnect)
-      return;
-    let mounted = true;
-    async function connect() {
-      try {
-        await adapter.connect?.();
-        if (mounted) {
-          setIsConnected(true);
-          setError(null);
-        }
-      } catch (err) {
-        if (mounted) {
-          setError(err instanceof Error ? err : new Error(String(err)));
-          setIsConnected(false);
-        }
-      }
-    }
-    connect();
-    return () => {
-      mounted = false;
-    };
-  }, [adapter, autoConnect]);
-  const setLang = useCallback((newLang) => {
-    setLangState(newLang);
-  }, []);
-  const dbContextValue = useMemo(() => ({
-    adapter,
-    schema,
-    isConnected,
-    error
-  }), [adapter, schema, isConnected, error]);
-  const langContextValue = useMemo(() => ({
-    lang,
-    fallbackLang,
-    setLang
-  }), [lang, fallbackLang, setLang]);
-  return /* @__PURE__ */ jsxDEV(QueryClientProvider, {
-    client: queryClient,
-    children: /* @__PURE__ */ jsxDEV(DbContext.Provider, {
-      value: dbContextValue,
-      children: /* @__PURE__ */ jsxDEV(DbLangContext.Provider, {
-        value: langContextValue,
-        children
-      }, undefined, false, undefined, this)
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this);
-}
-function useDb() {
-  const context = useContext(DbContext);
-  if (!context) {
-    throw new Error("useDb must be used within a DbProvider");
-  }
-  return context;
-}
-function useAdapter() {
-  const { adapter } = useDb();
-  return adapter;
-}
-function useDbLang() {
-  const context = useContext(DbLangContext);
-  if (!context) {
-    throw new Error("useDbLang must be used within a DbProvider");
-  }
-  return context;
-}
-// hooks/useDbHooks.ts
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { resolvePopulate } from "@promakeai/orm";
-function useDbList(table, options) {
-  const adapter = useAdapter();
-  const { schema } = useDb();
-  const { lang, fallbackLang } = useDbLang();
-  const { populate, ...queryOpts } = options || {};
-  return useQuery({
-    queryKey: [table, "list", queryOpts, lang, populate],
-    queryFn: async () => {
-      const records = await adapter.list(table, {
-        ...queryOpts,
-        lang,
-        fallbackLang
-      });
-      if (populate && schema) {
-        const adapterWrapper = {
-          findMany: (t, opts) => adapter.list(t, { ...opts, lang, fallbackLang })
-        };
-        return resolvePopulate(records, table, populate, schema, adapterWrapper);
-      }
-      return records;
-    },
-    enabled: options?.enabled ?? true
-  });
-}
-function useDbGet(table, idOrOptions, maybeOptions) {
-  const adapter = useAdapter();
-  const { schema } = useDb();
-  const { lang, fallbackLang } = useDbLang();
-  const isWhereMode = typeof idOrOptions === "object" && idOrOptions !== null && "where" in idOrOptions;
-  const where = isWhereMode ? idOrOptions.where : { id: idOrOptions };
-  const enabled = isWhereMode ? idOrOptions.enabled ?? true : (maybeOptions?.enabled ?? true) && idOrOptions !== undefined;
-  const populate = isWhereMode ? idOrOptions.populate : maybeOptions?.populate;
-  return useQuery({
-    queryKey: [table, "single", where, lang, populate],
-    queryFn: async () => {
-      const record = await adapter.findOne(table, { where, lang, fallbackLang });
-      if (record && populate && schema) {
-        const adapterWrapper = {
-          findMany: (t, opts) => adapter.list(t, { ...opts, lang, fallbackLang })
-        };
-        const [populated] = await resolvePopulate([record], table, populate, schema, adapterWrapper);
-        return populated;
-      }
-      return record;
-    },
-    enabled
-  });
-}
-function useDbCreate(table) {
-  const adapter = useAdapter();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data) => adapter.create(table, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: [table] });
-    }
-  });
-}
-function useDbUpdate(table) {
-  const adapter = useAdapter();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({ id, data }) => adapter.update(table, id, data),
-    onSuccess: (_, { id }) => {
-      queryClient.invalidateQueries({ queryKey: [table] });
-      queryClient.invalidateQueries({ queryKey: [table, "single", id] });
-    }
-  });
-}
-function useDbDelete(table) {
-  const adapter = useAdapter();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (id) => adapter.delete(table, id),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: [table] });
-    }
-  });
-}
-// adapters/SqliteAdapter.ts
-import initSqlJs from "sql.js";
-import {
-  buildWhereClause,
-  buildTranslationQuery,
-  buildTranslationQueryById,
-  buildTranslationUpsert,
-  extractTranslatableData,
-  getTranslatableFields,
-  toTranslationTableName,
-  toTranslationFKName,
-  deserializeRow,
-  serializeRow
-} from "@promakeai/orm";
-
-class SqliteAdapter {
-  db = null;
-  SQL = null;
-  tableColumnsCache = new Map;
-  config;
-  schema;
-  defaultLang;
-  constructor(config = {}) {
-    this.config = {
-      storageKey: config.storageKey ?? "dbreact_db",
-      wasmPath: config.wasmPath ?? "https://sql.js.org/dist/sql-wasm.wasm",
-      initialData: config.initialData ?? new Uint8Array,
-      schema: config.schema,
-      defaultLang: config.defaultLang
-    };
-    this.schema = config.schema;
-    this.defaultLang = config.defaultLang;
-  }
-  setSchema(schema) {
-    this.schema = schema;
-    this.config.schema = schema;
-    this.tableColumnsCache.clear();
-  }
-  async connect() {
-    this.SQL = await initSqlJs({
-      locateFile: (file) => file === "sql-wasm.wasm" ? this.config.wasmPath : file
-    });
-    const saved = localStorage.getItem(this.config.storageKey);
-    if (saved) {
-      const data = Uint8Array.from(atob(saved), (c) => c.charCodeAt(0));
-      this.db = new this.SQL.Database(data);
-    } else if (this.config.initialData.length > 0) {
-      this.db = new this.SQL.Database(this.config.initialData);
-      this.persist();
-    } else {
-      this.db = new this.SQL.Database;
-    }
-  }
-  persist() {
-    if (!this.db)
-      return;
-    const data = this.db.export();
-    const base64 = btoa(String.fromCharCode(...data));
-    localStorage.setItem(this.config.storageKey, base64);
-  }
-  getDb() {
-    if (!this.db) {
-      throw new Error("Database not connected. Call connect() first.");
-    }
-    return this.db;
-  }
-  runQuery(sql, params = []) {
-    const db = this.getDb();
-    const result = db.exec(sql, params);
-    if (result.length === 0 || result[0].values.length === 0) {
-      return [];
-    }
-    const columns = result[0].columns;
-    return result[0].values.map((row) => {
-      const obj = {};
-      columns.forEach((col, i) => {
-        obj[col] = row[i];
-      });
-      return obj;
-    });
-  }
-  deserializeResults(table, rows) {
-    const tableSchema = this.schema?.tables[table];
-    if (!tableSchema || rows.length === 0)
-      return rows;
-    return rows.map((row) => deserializeRow(row, tableSchema.fields));
-  }
-  serializeData(table, data) {
-    const tableSchema = this.schema?.tables[table];
-    if (!tableSchema)
-      return data;
-    return serializeRow(data, tableSchema.fields);
-  }
-  buildSelectQuery(table, options, countOnly = false) {
-    const select = countOnly ? "COUNT(*) as count" : "*";
-    let sql = `SELECT ${select} FROM ${table}`;
-    const params = [];
-    if (options?.where) {
-      const where = buildWhereClause(options.where);
-      if (where.sql) {
-        sql += ` WHERE ${where.sql}`;
-        params.push(...where.params);
-      }
-    }
-    if (!countOnly) {
-      if (options?.orderBy && options.orderBy.length > 0) {
-        const orderParts = options.orderBy.map((o) => `${o.field} ${o.direction}`);
-        sql += ` ORDER BY ${orderParts.join(", ")}`;
-      }
-      if (options?.limit !== undefined) {
-        sql += ` LIMIT ?`;
-        params.push(options.limit);
-      }
-      if (options?.offset !== undefined) {
-        sql += ` OFFSET ?`;
-        params.push(options.offset);
-      }
-    }
-    return { sql, params };
-  }
-  async list(table, options) {
-    if (options?.lang && this.schema?.tables[table]) {
-      return this.listWithLang(table, options);
-    }
-    const { sql, params } = this.buildSelectQuery(table, options);
-    const rows = this.runQuery(sql, params);
-    return this.deserializeResults(table, rows);
-  }
-  async listWithLang(table, options) {
-    const tableSchema = this.schema?.tables[table];
-    if (!tableSchema) {
-      const { sql: sql2, params: params2 } = this.buildSelectQuery(table, options);
-      return this.deserializeResults(table, this.runQuery(sql2, params2));
-    }
-    const translatableFields = getTranslatableFields(tableSchema);
-    if (translatableFields.length === 0) {
-      const { sql: sql2, params: params2 } = this.buildSelectQuery(table, options);
-      return this.deserializeResults(table, this.runQuery(sql2, params2));
-    }
-    const { sql, params } = buildTranslationQuery({
-      table,
-      schema: this.schema,
-      lang: options.lang,
-      fallbackLang: options.fallbackLang ?? this.defaultLang,
-      mainFallbackFields: await this.getAvailableMainFallbackFields(table),
-      where: options.where,
-      orderBy: options.orderBy,
-      limit: options.limit,
-      offset: options.offset
-    });
-    return this.deserializeResults(table, this.runQuery(sql, params));
-  }
-  async get(table, id, options) {
-    if (options?.lang && this.schema?.tables[table]) {
-      return this.getWithLang(table, id, options);
-    }
-    const results = await this.list(table, { where: { id }, limit: 1 });
-    return results[0] ?? null;
-  }
-  async findOne(table, options) {
-    const results = await this.list(table, { ...options, limit: 1 });
-    return results[0] ?? null;
-  }
-  async getWithLang(table, id, options) {
-    const tableSchema = this.schema?.tables[table];
-    if (!tableSchema) {
-      const results = await this.list(table, { where: { id }, limit: 1 });
-      return results[0] ?? null;
-    }
-    const translatableFields = getTranslatableFields(tableSchema);
-    if (translatableFields.length === 0) {
-      const results = await this.list(table, { where: { id }, limit: 1 });
-      return results[0] ?? null;
-    }
-    const { sql, params } = buildTranslationQueryById(table, this.schema, id, options.lang, options.fallbackLang ?? this.defaultLang, await this.getAvailableMainFallbackFields(table));
-    const rows = this.runQuery(sql, params);
-    const deserialized = this.deserializeResults(table, rows);
-    return deserialized[0] ?? null;
-  }
-  async count(table, options) {
-    const { sql, params } = this.buildSelectQuery(table, options, true);
-    const result = this.runQuery(sql, params);
-    return result[0]?.count ?? 0;
-  }
-  async paginate(table, page, limit, options) {
-    const total = await this.count(table, options);
-    const totalPages = Math.ceil(total / limit);
-    const offset = (page - 1) * limit;
-    const data = await this.list(table, {
-      ...options,
-      limit,
-      offset
-    });
-    return {
-      data,
-      page,
-      limit,
-      total,
-      totalPages,
-      hasMore: page < totalPages
-    };
-  }
-  async create(table, data) {
-    const db = this.getDb();
-    const tableSchema = this.schema?.tables[table];
-    const serializedData = this.serializeData(table, data);
-    if (tableSchema) {
-      const { mainData, translatableData } = extractTranslatableData(serializedData, tableSchema);
-      const columns2 = Object.keys(mainData);
-      const values2 = Object.values(mainData);
-      const placeholders2 = columns2.map(() => "?").join(", ");
-      const sql2 = `INSERT INTO ${table} (${columns2.join(", ")}) VALUES (${placeholders2})`;
-      db.run(sql2, values2);
-      const lastId2 = db.exec("SELECT last_insert_rowid() as id")[0].values[0][0];
-      this.persist();
-      if (Object.keys(translatableData).length > 0 && this.defaultLang) {
-        await this.upsertTranslation(table, lastId2, this.defaultLang, translatableData);
-      }
-      const result2 = await this.get(table, lastId2);
-      return result2;
-    }
-    const columns = Object.keys(serializedData);
-    const values = Object.values(serializedData);
-    const placeholders = columns.map(() => "?").join(", ");
-    const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
-    db.run(sql, values);
-    const lastId = db.exec("SELECT last_insert_rowid() as id")[0].values[0][0];
-    this.persist();
-    const result = await this.get(table, lastId);
-    return result;
-  }
-  async createWithTranslations(table, data, translations) {
-    const db = this.getDb();
-    const tableSchema = this.schema?.tables[table];
-    const serializedData = this.serializeData(table, data);
-    let mainData = serializedData;
-    let translatableData = {};
-    if (tableSchema) {
-      const extracted = extractTranslatableData(serializedData, tableSchema);
-      mainData = extracted.mainData;
-      translatableData = extracted.translatableData;
-    }
-    const columns = Object.keys(mainData);
-    const values = Object.values(mainData);
-    const placeholders = columns.map(() => "?").join(", ");
-    const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
-    db.run(sql, values);
-    const lastId = db.exec("SELECT last_insert_rowid() as id")[0].values[0][0];
-    if (translations) {
-      for (const [lang, langData] of Object.entries(translations)) {
-        await this.upsertTranslation(table, lastId, lang, langData);
-      }
-    } else if (Object.keys(translatableData).length > 0 && this.defaultLang) {
-      await this.upsertTranslation(table, lastId, this.defaultLang, translatableData);
-    }
-    this.persist();
-    const result = await this.get(table, lastId);
-    return result;
-  }
-  async update(table, id, data) {
-    const db = this.getDb();
-    const tableSchema = this.schema?.tables[table];
-    const serializedData = this.serializeData(table, data);
-    if (tableSchema) {
-      const { mainData, translatableData } = extractTranslatableData(serializedData, tableSchema);
-      if (Object.keys(mainData).length > 0) {
-        const columns2 = Object.keys(mainData);
-        const values2 = Object.values(mainData);
-        const setParts2 = columns2.map((col) => `${col} = ?`).join(", ");
-        const sql2 = `UPDATE ${table} SET ${setParts2} WHERE id = ?`;
-        db.run(sql2, [...values2, id]);
-      }
-      if (Object.keys(translatableData).length > 0 && this.defaultLang) {
-        await this.upsertTranslation(table, id, this.defaultLang, translatableData);
-      }
-      this.persist();
-      const result2 = await this.get(table, id);
-      return result2;
-    }
-    const columns = Object.keys(serializedData);
-    const values = Object.values(serializedData);
-    const setParts = columns.map((col) => `${col} = ?`).join(", ");
-    const sql = `UPDATE ${table} SET ${setParts} WHERE id = ?`;
-    db.run(sql, [...values, id]);
-    this.persist();
-    const result = await this.get(table, id);
-    return result;
-  }
-  async upsertTranslation(table, id, lang, data) {
-    const db = this.getDb();
-    if (!this.schema) {
-      throw new Error(`No schema found for table: ${table}`);
-    }
-    const { sql, params } = buildTranslationUpsert(table, this.schema, id, lang, data);
-    db.run(sql, params);
-    this.persist();
-  }
-  async getTranslations(table, id) {
-    const tableSchema = this.schema?.tables[table];
-    if (!tableSchema) {
-      return [];
-    }
-    const translationTable = toTranslationTableName(table);
-    const fkName = toTranslationFKName(table);
-    const sql = `SELECT * FROM ${translationTable} WHERE ${fkName} = ?`;
-    return this.runQuery(sql, [id]);
-  }
-  async delete(table, id) {
-    const db = this.getDb();
-    if (this.schema?.tables[table]) {
-      const translationTable = toTranslationTableName(table);
-      const fkName = toTranslationFKName(table);
-      try {
-        db.run(`DELETE FROM ${translationTable} WHERE ${fkName} = ?`, [id]);
-      } catch {}
-    }
-    const sql = `DELETE FROM ${table} WHERE id = ?`;
-    db.run(sql, [id]);
-    this.persist();
-    const changes = db.getRowsModified();
-    return changes > 0;
-  }
-  async execute(query, params) {
-    const db = this.getDb();
-    db.run(query, params);
-    this.persist();
-    const changes = db.getRowsModified();
-    const result = db.exec("SELECT last_insert_rowid() as id");
-    const lastInsertRowid = result[0]?.values[0]?.[0] ?? 0;
-    return { changes, lastInsertRowid };
-  }
-  async raw(query, params) {
-    return this.runQuery(query, params ?? []);
-  }
-  async seed(data) {
-    const db = this.getDb();
-    for (const [table, records] of Object.entries(data)) {
-      for (const record of records) {
-        const serialized = this.serializeData(table, record);
-        const columns = Object.keys(serialized);
-        const values = Object.values(serialized);
-        const placeholders = columns.map(() => "?").join(", ");
-        const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
-        db.run(sql, values);
-      }
-    }
-    this.persist();
-  }
-  async getTables() {
-    const result = this.runQuery("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
-    return result.map((row) => row.name);
-  }
-  async getTableSchema(table) {
-    const db = this.getDb();
-    const result = db.exec(`PRAGMA table_info(${table})`);
-    if (result.length === 0 || result[0].values.length === 0) {
-      return [];
-    }
-    return result[0].values.map((row) => ({
-      name: String(row[1]),
-      type: String(row[2]),
-      notnull: Number(row[3]),
-      pk: Number(row[5])
-    }));
-  }
-  close() {
-    if (this.db) {
-      this.persist();
-      this.db.close();
-      this.db = null;
-      this.tableColumnsCache.clear();
-    }
-  }
-  async beginTransaction() {
-    await this.execute("BEGIN TRANSACTION");
-  }
-  async commit() {
-    await this.execute("COMMIT");
-    this.persist();
-  }
-  async rollback() {
-    await this.execute("ROLLBACK");
-  }
-  async createMany(table, records, options) {
-    const db = this.getDb();
-    const ids = [];
-    const tableSchema = this.schema?.tables[table];
-    for (const record of records) {
-      const serializedRecord = this.serializeData(table, record);
-      let mainData = serializedRecord;
-      let translatableData = {};
-      if (tableSchema) {
-        const extracted = extractTranslatableData(serializedRecord, tableSchema);
-        mainData = extracted.mainData;
-        translatableData = extracted.translatableData;
-      }
-      const columns = Object.keys(mainData);
-      const values = Object.values(mainData);
-      const placeholders = columns.map(() => "?").join(", ");
-      const insertType = options?.ignore ? "INSERT OR IGNORE" : "INSERT";
-      const sql = `${insertType} INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
-      db.run(sql, values);
-      const lastId = db.exec("SELECT last_insert_rowid() as id")[0].values[0][0];
-      if (db.getRowsModified() > 0) {
-        ids.push(lastId);
-        if (Object.keys(translatableData).length > 0 && this.defaultLang) {
-          await this.upsertTranslation(table, lastId, this.defaultLang, translatableData);
-        }
-      }
-    }
-    this.persist();
-    return { created: ids.length, ids };
-  }
-  async getAvailableMainFallbackFields(table) {
-    const tableSchema = this.schema?.tables[table];
-    if (!tableSchema)
-      return [];
-    const translatableFields = getTranslatableFields(tableSchema);
-    if (translatableFields.length === 0)
-      return [];
-    const tableColumns = await this.getTableColumns(table);
-    return translatableFields.filter((field) => tableColumns.has(field));
-  }
-  async getTableColumns(table) {
-    const cached = this.tableColumnsCache.get(table);
-    if (cached)
-      return cached;
-    const schema = await this.getTableSchema(table);
-    const columnSet = new Set(schema.map((col) => col.name));
-    this.tableColumnsCache.set(table, columnSet);
-    return columnSet;
-  }
-  async updateMany(table, updates) {
-    let updated = 0;
-    for (const { id, data } of updates) {
-      await this.update(table, id, data);
-      updated++;
-    }
-    return { updated };
-  }
-  async deleteMany(table, ids) {
-    let deleted = 0;
-    for (const id of ids) {
-      const success = await this.delete(table, id);
-      if (success)
-        deleted++;
-    }
-    return { deleted };
-  }
-  export() {
-    return this.getDb().export();
-  }
-  async import(data) {
-    if (!this.SQL) {
-      throw new Error("Database not connected. Call connect() first.");
-    }
-    this.db?.close();
-    this.db = new this.SQL.Database(data);
-    this.persist();
-  }
-  clear() {
-    if (!this.SQL) {
-      throw new Error("Database not connected. Call connect() first.");
-    }
-    this.db?.close();
-    this.db = new this.SQL.Database;
-    this.persist();
-  }
-}
-export {
-  validatePopulate,
-  useDbUpdate,
-  useDbList,
-  useDbLang,
-  useDbGet,
-  useDbDelete,
-  useDbCreate,
-  useDb,
-  useAdapter,
-  resolvePopulate2 as resolvePopulate,
-  parseJSONSchema,
-  getPopulatableFields,
-  f,
-  defineSchema,
-  buildWhereClause2 as buildWhereClause,
-  SqliteAdapter,
-  ORM,
-  DbProvider
-};
+/**
+ * @promakeai/dbreact
+ *
+ * React client for schema-driven multi-language database.
+ * Works with SQL.js (browser SQLite) or REST API backends.
+ */
+// Re-export ORM core for browser usage
+export { ORM, defineSchema, f, buildWhereClause, resolvePopulate, getPopulatableFields, validatePopulate, parseJSONSchema, } from "@promakeai/orm";
+// Provider
+export { DbProvider, useDb, useAdapter, useDbLang, } from "./providers/DbProvider";
+// Generic Hooks
+export { useDbList, useDbGet, useDbCreate, useDbUpdate, useDbDelete, } from "./hooks/useDbHooks";
+// Adapters
+export { SqliteAdapter } from "./adapters/SqliteAdapter";

package/dist/providers/DbProvider.js

@@ -42,7 +42,7 @@ const defaultQueryClient = new QueryClient({
  * }
  * ```
  */
-export function DbProvider({ adapter, lang: langProp = "en", fallbackLang = "en", autoConnect = true, queryClient = defaultQueryClient, children, }) {
+export function DbProvider({ adapter, schema, lang: langProp = "en", fallbackLang = "en", autoConnect = true, queryClient = defaultQueryClient, children, }) {
     const [isConnected, setIsConnected] = useState(false);
     const [error, setError] = useState(null);
     const [lang, setLangState] = useState(langProp);
@@ -94,9 +94,10 @@ export function DbProvider({ adapter, lang: langProp = "en", fallbackLang = "en"
     // Database context value
     const dbContextValue = useMemo(() => ({
         adapter,
+        schema,
         isConnected,
         error,
-    }), [adapter, isConnected, error]);
+    }), [adapter, schema, isConnected, error]);
     // Language context value
     const langContextValue = useMemo(() => ({
         lang,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promakeai/dbreact",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "React client for schema-driven multi-language database",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -14,10 +14,12 @@
     }
   },
   "scripts": {
-    "build": "bun build index.ts --outdir dist --target browser --packages=external && bun run build:types",
+    "build:js": "tsc --project tsconfig.json --declaration false --declarationMap false --emitDeclarationOnly false --outDir dist",
+    "build": "bun run build:js && bun run build:types",
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist",
     "dev": "bun build index.ts --outdir dist --target browser --packages=external --watch",
     "test": "bun test",
+    "test:build-runtime": "bun run build && bun test ./tests/build-runtime.test.ts",
     "typecheck": "tsc --noEmit",
     "release": "bun run build && npm publish --access public"
   },
@@ -40,7 +42,7 @@
     "sql.js": ">=1.11.0"
   },
   "dependencies": {
-    "@promakeai/orm": "1.0.4"
+    "@promakeai/orm": "1.0.5"
   },
   "devDependencies": {
     "@tanstack/query-core": "5.90.20",