@promakeai/dbreact 1.0.1 → 1.0.4

package/dist/core/DataManager.d.ts

@@ -0,0 +1,147 @@
+/**
+ * DataManager for React Client
+ *
+ * Central data access layer for the React client.
+ * Provides language-aware query methods using raw SQL when needed.
+ */
+import type { IDataAdapter, QueryOptions, PaginatedResult, LangQueryOptions } from "../types";
+/**
+ * Schema definition for language-aware queries
+ */
+export interface TableSchema {
+    translatableFields?: string[];
+    translationTable?: string;
+    foreignKey?: string;
+}
+/**
+ * DataManager - Central data access layer for React
+ *
+ * Acts as a proxy to the underlying adapter with language-aware query support.
+ *
+ * @example
+ * ```ts
+ * const dm = useDataManager();
+ * const products = await dm.query('products', { lang: 'tr' });
+ * ```
+ */
+export declare class DataManager {
+    private adapter;
+    private schemas;
+    constructor(adapter: IDataAdapter);
+    /**
+     * Register a table schema for language-aware queries
+     */
+    registerSchema(table: string, schema: TableSchema): void;
+    /**
+     * Get registered schema for a table
+     */
+    getSchema(table: string): TableSchema | undefined;
+    /**
+     * Query multiple records
+     */
+    query<T = unknown>(table: string, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Query a single record
+     */
+    queryOne<T = unknown>(table: string, options?: QueryOptions): Promise<T | null>;
+    /**
+     * Get a record by ID
+     */
+    queryById<T = unknown>(table: string, id: number | string): Promise<T | null>;
+    /**
+     * Count records
+     */
+    count(table: string, options?: QueryOptions): Promise<number>;
+    /**
+     * Paginated query
+     */
+    paginate<T = unknown>(table: string, page: number, limit: number, options?: QueryOptions): Promise<PaginatedResult<T>>;
+    /**
+     * Create a new record
+     */
+    create<T = unknown>(table: string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Update a record by ID
+     */
+    update<T = unknown>(table: string, id: number | string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Delete a record by ID
+     */
+    delete(table: string, id: number | string): Promise<boolean>;
+    /**
+     * Execute raw SQL/query
+     */
+    execute(query: string, params?: unknown[]): Promise<void>;
+    /**
+     * Execute raw SQL query (SELECT)
+     */
+    executeQuery<T = unknown>(query: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Bulk seed data
+     */
+    seed(data: Record<string, Record<string, unknown>[]>): Promise<void>;
+    /**
+     * Get all table names
+     */
+    getTables(): Promise<string[]>;
+    /**
+     * Get table schema
+     */
+    getTableSchema(table: string): Promise<{
+        name: string;
+        type: string;
+        notnull: number;
+        pk: number;
+    }[]>;
+    /**
+     * Close connection
+     */
+    close(): void;
+    /**
+     * Get the underlying adapter
+     */
+    getAdapter(): IDataAdapter;
+    /**
+     * Query with automatic translation support
+     *
+     * If a schema is registered for the table with translatable fields,
+     * this will perform a JOIN with the translation table and use COALESCE
+     * to fallback to the default language.
+     *
+     * @example
+     * ```ts
+     * dm.registerSchema('products', {
+     *   translatableFields: ['name', 'description'],
+     *   translationTable: 'product_translations',
+     *   foreignKey: 'product_id'
+     * });
+     *
+     * const products = await dm.queryWithLang('products', {
+     *   lang: 'tr',
+     *   fallbackLang: 'en'
+     * });
+     * ```
+     */
+    queryWithLang<T = unknown>(table: string, options?: LangQueryOptions): Promise<T[]>;
+    /**
+     * Query single record by ID with translation support
+     */
+    queryByIdWithLang<T = unknown>(table: string, id: number | string, options?: {
+        lang?: string;
+        fallbackLang?: string;
+    }): Promise<T | null>;
+    /**
+     * Create record with translations
+     */
+    createWithTranslations<T = unknown>(table: string, data: Record<string, unknown>, translations: Record<string, Record<string, unknown>>): Promise<T>;
+    /**
+     * Update or insert translation for specific language
+     */
+    upsertTranslation(table: string, id: number | string, lang: string, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Get all translations for a record
+     */
+    getTranslations<T = unknown>(table: string, id: number | string): Promise<T[]>;
+    private buildTranslationQuery;
+}
+//# sourceMappingURL=DataManager.d.ts.map

package/dist/hooks/useDataManager.d.ts

@@ -0,0 +1,7 @@
+/**
+ * useDataManager Hook
+ *
+ * Access DataManager from DbProvider.
+ */
+export { useDataManager } from "../providers/DbProvider";
+//# sourceMappingURL=useDataManager.d.ts.map

package/dist/hooks/useDbHooks.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Generic Database Hooks
+ *
+ * Type-safe React hooks for database operations.
+ * Works with any table - just pass the table name and type.
+ *
+ * @example
+ * ```tsx
+ * import { useDbList, useDbGet, useDbCreate } from '@promakeai/dbreact';
+ * import type { DbProduct } from './db/types';
+ *
+ * // List all products
+ * const { data } = useDbList<DbProduct>('products');
+ *
+ * // Get single product
+ * const { data } = useDbGet<DbProduct>('products', productId);
+ *
+ * // Create product
+ * const mutation = useDbCreate<DbProduct>('products');
+ * mutation.mutate({ name: 'New Product' });
+ * ```
+ */
+import { type PopulateOption } from "@promakeai/orm";
+/**
+ * List options for useDbList
+ */
+export interface ListOptions {
+    where?: Record<string, unknown>;
+    orderBy?: Array<{
+        field: string;
+        direction: "ASC" | "DESC";
+    }>;
+    limit?: number;
+    offset?: number;
+    enabled?: boolean;
+    populate?: PopulateOption;
+}
+/**
+ * Hook to list all records from a table
+ *
+ * @param table - Table name
+ * @param options - Query options (where, orderBy, limit, offset, enabled)
+ * @returns React Query result with data array
+ *
+ * @example
+ * ```tsx
+ * const { data: products, isLoading } = useDbList<DbProduct>('products', {
+ *   where: { price: { $gt: 100 } },
+ *   orderBy: [{ field: 'name', direction: 'ASC' }],
+ *   limit: 10,
+ * });
+ * ```
+ */
+export declare function useDbList<T>(table: string, options?: ListOptions): import("@tanstack/react-query").UseQueryResult<T[], Error>;
+/**
+ * Options for findOne-style queries
+ */
+export interface FindOneOptions {
+    where: Record<string, unknown>;
+    enabled?: boolean;
+    populate?: PopulateOption;
+}
+/**
+ * Hook to get a single record by ID or where query
+ *
+ * @param table - Table name
+ * @param idOrOptions - Record ID, or FindOneOptions with where clause
+ * @param maybeOptions - Query options when using ID form
+ * @returns React Query result with single record or null
+ *
+ * @example
+ * ```tsx
+ * // By ID
+ * const { data: product } = useDbGet<DbProduct>('products', productId);
+ *
+ * // By where query (findOne style)
+ * const { data: product } = useDbGet<DbProduct>('products', {
+ *   where: { slug: 'my-product' },
+ *   enabled: !!slug,
+ * });
+ * ```
+ */
+export declare function useDbGet<T>(table: string, idOrOptions: number | undefined | FindOneOptions, maybeOptions?: {
+    enabled?: boolean;
+    populate?: PopulateOption;
+}): import("@tanstack/react-query").UseQueryResult<import("@tanstack/query-core").NoInfer<T | null>, Error>;
+/**
+ * Hook to create a new record
+ *
+ * @param table - Table name
+ * @returns React Query mutation for creating records
+ *
+ * @example
+ * ```tsx
+ * const mutation = useDbCreate<DbProduct>('products');
+ *
+ * mutation.mutate({ sku: 'ABC', price: 100 });
+ * ```
+ */
+export declare function useDbCreate<T, TInput = Partial<T>>(table: string): import("@tanstack/react-query").UseMutationResult<T, Error, TInput, unknown>;
+/**
+ * Hook to update an existing record
+ *
+ * @param table - Table name
+ * @returns React Query mutation for updating records
+ *
+ * @example
+ * ```tsx
+ * const mutation = useDbUpdate<DbProduct>('products');
+ *
+ * mutation.mutate({ id: 1, data: { price: 150 } });
+ * ```
+ */
+export declare function useDbUpdate<T, TInput = Partial<T>>(table: string): import("@tanstack/react-query").UseMutationResult<T, Error, {
+    id: number;
+    data: TInput;
+}, unknown>;
+/**
+ * Hook to delete a record
+ *
+ * @param table - Table name
+ * @returns React Query mutation for deleting records
+ *
+ * @example
+ * ```tsx
+ * const mutation = useDbDelete('products');
+ *
+ * mutation.mutate(productId);
+ * ```
+ */
+export declare function useDbDelete(table: string): import("@tanstack/react-query").UseMutationResult<boolean, Error, number, unknown>;
+//# sourceMappingURL=useDbHooks.d.ts.map

package/dist/hooks/useDbHooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDbHooks.d.ts","sourceRoot":"","sources":["../../hooks/useDbHooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,8DAchE;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,cAAc,EAChD,YAAY,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,2GAgBrC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,gFAUhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM;QAO7B,MAAM;UAAQ,MAAM;YAKvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,sFAUxC"}
+{"version":3,"file":"useDbHooks.d.ts","sourceRoot":"","sources":["../../hooks/useDbHooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,8DA2BhE;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,cAAc,EAChD,YAAY,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAAE,2GAqChE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,gFAUhE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM;QAO7B,MAAM;UAAQ,MAAM;YAKvD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,sFAUxC"}

package/dist/hooks/useDbLang.d.ts

@@ -0,0 +1,7 @@
+/**
+ * useDbLang Hook
+ *
+ * Access language context from DbProvider.
+ */
+export { useDbLang } from "../providers/DbProvider";
+//# sourceMappingURL=useDbLang.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @promakeai/dbreact
+ *
+ * React client for schema-driven multi-language database.
+ * Works with SQL.js (browser SQLite) or REST API backends.
+ */
+export { ORM, defineSchema, f, buildWhereClause, resolvePopulate, getPopulatableFields, validatePopulate, parseJSONSchema, } from "@promakeai/orm";
+export type { SchemaDefinition, TableDefinition, FieldDefinition, PopulateOption, PopulateNested, ORMConfig, QueryOptions, PaginatedResult, IDataAdapter, WhereResult, } from "@promakeai/orm";
+export type { DbProviderConfig, DbLangContextValue, DbContextValue, } from "./types";
+export { DbProvider, useDb, useAdapter, useDbLang, } from "./providers/DbProvider";
+export { useDbList, useDbGet, useDbCreate, useDbUpdate, useDbDelete, type ListOptions, type FindOneOptions, } from "./hooks/useDbHooks";
+export { SqliteAdapter, type SqliteAdapterConfig } from "./adapters/SqliteAdapter";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   defineSchema,
   f,
   buildWhereClause as buildWhereClause2,
-  resolvePopulate,
+  resolvePopulate as resolvePopulate2,
   getPopulatableFields,
   validatePopulate,
   parseJSONSchema
@@ -35,6 +35,7 @@ var defaultQueryClient = new QueryClient({
 });
 function DbProvider({
   adapter,
+  schema,
   lang: langProp = "en",
   fallbackLang = "en",
   autoConnect = true,
@@ -85,9 +86,10 @@ function DbProvider({
   }, []);
   const dbContextValue = useMemo(() => ({
     adapter,
+    schema,
     isConnected,
     error
-  }), [adapter, isConnected, error]);
+  }), [adapter, schema, isConnected, error]);
   const langContextValue = useMemo(() => ({
     lang,
     fallbackLang,
@@ -124,28 +126,52 @@ function useDbLang() {
 }
 // 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", 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
   });
 }
 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
   });
 }
@@ -198,6 +224,7 @@ import {
 class SqliteAdapter {
   db = null;
   SQL = null;
+  tableColumnsCache = new Map;
   config;
   schema;
   defaultLang;
@@ -215,6 +242,7 @@ class SqliteAdapter {
   setSchema(schema) {
     this.schema = schema;
     this.config.schema = schema;
+    this.tableColumnsCache.clear();
   }
   async connect() {
     this.SQL = await initSqlJs({
@@ -322,6 +350,7 @@ 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,
@@ -351,7 +380,7 @@ 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;
@@ -547,6 +576,7 @@ class SqliteAdapter {
       this.persist();
       this.db.close();
       this.db = null;
+      this.tableColumnsCache.clear();
     }
   }
   async beginTransaction() {
@@ -589,6 +619,25 @@ 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) {
@@ -636,7 +685,7 @@ export {
   useDbCreate,
   useDb,
   useAdapter,
-  resolvePopulate,
+  resolvePopulate2 as resolvePopulate,
   parseJSONSchema,
   getPopulatableFields,
   f,

package/dist/providers/DbProvider.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Database Provider
+ *
+ * React context provider for database operations with language support.
+ */
+import { type ReactNode } from "react";
+import { QueryClient } from "@tanstack/react-query";
+import type { IDataAdapter, DbProviderConfig, DbLangContextValue, DbContextValue } from "../types";
+interface DbProviderProps extends DbProviderConfig {
+    children: ReactNode;
+    queryClient?: QueryClient;
+}
+/**
+ * Database Provider Component
+ *
+ * Wraps application with database context, language context, and React Query.
+ *
+ * @example
+ * ```tsx
+ * import { DbProvider, SqliteAdapter } from '@promakeai/dbreact';
+ *
+ * const adapter = new SqliteAdapter({ storageKey: 'myapp' });
+ *
+ * function App() {
+ *   return (
+ *     <DbProvider adapter={adapter} lang="tr" fallbackLang="en">
+ *       <MyApp />
+ *     </DbProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function DbProvider({ adapter, schema, lang: langProp, fallbackLang, autoConnect, queryClient, children, }: DbProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access database context
+ */
+export declare function useDb(): DbContextValue;
+/**
+ * Hook to access the raw adapter
+ */
+export declare function useAdapter(): IDataAdapter;
+/**
+ * Hook to access language context
+ */
+export declare function useDbLang(): DbLangContextValue;
+export {};
+//# sourceMappingURL=DbProvider.d.ts.map

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

@@ -1 +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"}
+{"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,MAAM,EACN,IAAI,EAAE,QAAe,EACrB,YAAmB,EACnB,WAAkB,EAClB,WAAgC,EAChC,QAAQ,GACT,EAAE,eAAe,2CAsFjB;AAED;;GAEG;AACH,wBAAgB,KAAK,IAAI,cAAc,CAMtC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,YAAY,CAGzC;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,kBAAkB,CAM9C"}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * dbreact Types
+ *
+ * Re-exports from @promakeai/orm and React-specific types.
+ */
+export type { IDataAdapter, QueryOptions, PaginatedResult, SchemaDefinition, } from "@promakeai/orm";
+/**
+ * Provider configuration
+ */
+export interface DbProviderConfig {
+    adapter: import("@promakeai/orm").IDataAdapter;
+    /** Schema definition for populate support */
+    schema?: import("@promakeai/orm").SchemaDefinition;
+    lang?: string;
+    fallbackLang?: string;
+    /** Auto-connect on mount (default: true) */
+    autoConnect?: boolean;
+}
+/**
+ * Language context value
+ */
+export interface DbLangContextValue {
+    lang: string;
+    fallbackLang: string;
+    setLang: (lang: string) => void;
+}
+/**
+ * Database context value
+ */
+export interface DbContextValue {
+    adapter: import("@promakeai/orm").IDataAdapter;
+    schema?: import("@promakeai/orm").SchemaDefinition;
+    isConnected: boolean;
+    error: Error | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,gBAAgB,EAAE,YAAY,CAAC;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,gBAAgB,EAAE,YAAY,CAAC;IAC/C,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,gBAAgB,EAAE,YAAY,CAAC;IAC/C,6CAA6C;IAC7C,MAAM,CAAC,EAAE,OAAO,gBAAgB,EAAE,gBAAgB,CAAC;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,gBAAgB,EAAE,YAAY,CAAC;IAC/C,MAAM,CAAC,EAAE,OAAO,gBAAgB,EAAE,gBAAgB,CAAC;IACnD,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB"}

package/dist/utils/whereBuilder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * MongoDB-style Where Clause Builder
+ *
+ * Converts MongoDB/Mongoose-style query objects into SQL WHERE clauses
+ * with parameterized values.
+ *
+ * Supported operators:
+ * - Comparison: $eq, $ne, $gt, $gte, $lt, $lte
+ * - Array: $in, $nin
+ * - String: $like, $notLike
+ * - Range: $between
+ * - Null: $isNull
+ * - Negation: $not (field-level)
+ * - Logical: $and, $or, $nor
+ */
+export interface WhereResult {
+    sql: string;
+    params: unknown[];
+}
+/**
+ * Build a SQL WHERE clause from a MongoDB-style query object.
+ *
+ * @example
+ * // Simple equality (backward compatible)
+ * buildWhereClause({ active: 1 })
+ * // => { sql: "active = ?", params: [1] }
+ *
+ * @example
+ * // Comparison operators
+ * buildWhereClause({ age: { $gte: 18, $lt: 65 } })
+ * // => { sql: "(age >= ? AND age < ?)", params: [18, 65] }
+ *
+ * @example
+ * // Logical operators
+ * buildWhereClause({ $or: [{ active: 1 }, { role: "admin" }] })
+ * // => { sql: "(active = ? OR role = ?)", params: [1, "admin"] }
+ */
+export declare function buildWhereClause(where?: Record<string, unknown>): WhereResult;
+//# sourceMappingURL=whereBuilder.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@promakeai/dbreact",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "description": "React client for schema-driven multi-language database",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -21,6 +21,9 @@
     "typecheck": "tsc --noEmit",
     "release": "bun run build && npm publish --access public"
   },
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "react",
     "database",
@@ -37,7 +40,7 @@
     "sql.js": ">=1.11.0"
   },
   "dependencies": {
-    "@promakeai/orm": "1.0.1"
+    "@promakeai/orm": "1.0.4"
   },
   "devDependencies": {
     "@tanstack/query-core": "5.90.20",