@promakeai/dbreact 1.0.1

package/dist/index.js

@@ -0,0 +1,648 @@
+// index.ts
+import {
+  ORM,
+  defineSchema,
+  f,
+  buildWhereClause as buildWhereClause2,
+  resolvePopulate,
+  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,
+  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,
+    isConnected,
+    error
+  }), [adapter, 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";
+function useDbList(table, options) {
+  const adapter = useAdapter();
+  const { lang, fallbackLang } = useDbLang();
+  return useQuery({
+    queryKey: [table, "list", options, lang],
+    queryFn: () => adapter.list(table, {
+      ...options,
+      lang,
+      fallbackLang
+    }),
+    enabled: options?.enabled ?? true
+  });
+}
+function useDbGet(table, idOrOptions, maybeOptions) {
+  const adapter = useAdapter();
+  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;
+  return useQuery({
+    queryKey: [table, "single", where, lang],
+    queryFn: () => adapter.findOne(table, { where, lang, fallbackLang }),
+    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;
+  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;
+  }
+  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,
+      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);
+    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;
+    }
+  }
+  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 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,
+  resolvePopulate,
+  parseJSONSchema,
+  getPopulatableFields,
+  f,
+  defineSchema,
+  buildWhereClause2 as buildWhereClause,
+  SqliteAdapter,
+  ORM,
+  DbProvider
+};

package/dist/providers/DbProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DbProvider.d.ts","sourceRoot":"","sources":["../../providers/DbProvider.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,WAAW,EAAuB,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACf,MAAM,UAAU,CAAC;AAqBlB,UAAU,eAAgB,SAAQ,gBAAgB;IAChD,QAAQ,EAAE,SAAS,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,IAAI,EAAE,QAAe,EACrB,YAAmB,EACnB,WAAkB,EAClB,WAAgC,EAChC,QAAQ,GACT,EAAE,eAAe,2CAqFjB;AAED;;GAEG;AACH,wBAAgB,KAAK,IAAI,cAAc,CAMtC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,YAAY,CAGzC;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,kBAAkB,CAM9C"}