@promakeai/dbreact 1.0.1 → 1.0.3

package/dist/adapters/RestAdapter.d.ts

@@ -0,0 +1,83 @@
+/**
+ * REST API Adapter
+ *
+ * Fetches data from a REST API backend.
+ * Sends Accept-Language header for multi-language support.
+ */
+import type { IDataAdapter, QueryOptions, PaginatedResult } from "../types";
+export interface RestAdapterConfig {
+    /** Base URL for API (e.g., "https://api.example.com") */
+    baseUrl: string;
+    /** Language code for Accept-Language header */
+    lang?: string;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+    /** Custom fetch function (for testing/SSR) */
+    fetch?: typeof fetch;
+}
+/**
+ * REST API Adapter
+ *
+ * Makes HTTP requests to a REST API backend.
+ *
+ * @example
+ * ```ts
+ * const adapter = new RestAdapter({
+ *   baseUrl: 'https://api.example.com',
+ *   lang: 'tr'
+ * });
+ * const users = await adapter.findMany('users');
+ * ```
+ */
+export declare class RestAdapter implements IDataAdapter {
+    private config;
+    constructor(config: RestAdapterConfig);
+    connect(): Promise<void>;
+    private buildUrl;
+    private getHeaders;
+    private request;
+    private buildQueryParams;
+    findMany<T = unknown>(table: string, options?: QueryOptions): Promise<T[]>;
+    findOne<T = unknown>(table: string, options?: QueryOptions): Promise<T | null>;
+    findById<T = unknown>(table: string, id: number | string): Promise<T | null>;
+    count(table: string, options?: QueryOptions): Promise<number>;
+    paginate<T = unknown>(table: string, page: number, limit: number, options?: QueryOptions): Promise<PaginatedResult<T>>;
+    create<T = unknown>(table: string, data: Record<string, unknown>): Promise<T>;
+    update<T = unknown>(table: string, id: number | string, data: Record<string, unknown>): Promise<T>;
+    delete(table: string, id: number | string): Promise<boolean>;
+    execute(_query: string, _params?: unknown[]): Promise<void>;
+    executeQuery<T = unknown>(_query: string, _params?: unknown[]): Promise<T[]>;
+    seed(data: Record<string, Record<string, unknown>[]>): Promise<void>;
+    getTables(): Promise<string[]>;
+    getTableSchema(table: string): Promise<{
+        name: string;
+        type: string;
+        notnull: number;
+        pk: number;
+    }[]>;
+    close(): void;
+    /**
+     * Update language for subsequent requests
+     */
+    setLang(lang: string): void;
+    /**
+     * Get current language
+     */
+    getLang(): string;
+    createMany<T = unknown>(table: string, records: Record<string, unknown>[], options?: {
+        ignore?: boolean;
+    }): Promise<{
+        created: number;
+        ids: (number | bigint)[];
+    }>;
+    updateMany(table: string, updates: {
+        id: number | string;
+        data: Record<string, unknown>;
+    }[]): Promise<{
+        updated: number;
+    }>;
+    deleteMany(table: string, ids: (number | string)[]): Promise<{
+        deleted: number;
+    }>;
+}
+//# sourceMappingURL=RestAdapter.d.ts.map

package/dist/adapters/SqliteAdapter.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Browser SQLite Adapter
+ *
+ * Uses sql.js (WASM) for in-browser SQLite database.
+ * Persists to localStorage for offline support.
+ */
+import type { IDataAdapter, QueryOptions, PaginatedResult, SchemaDefinition } from "@promakeai/orm";
+export interface SqliteAdapterConfig {
+    /** localStorage key for persistence (default: "dbreact_db") */
+    storageKey?: string;
+    /** sql.js WASM path (default: CDN) */
+    wasmPath?: string;
+    /** Initial data to seed if database is empty */
+    initialData?: Uint8Array;
+    /** Schema definition for translation support */
+    schema?: SchemaDefinition;
+    /** Default language for translations */
+    defaultLang?: string;
+}
+/**
+ * Browser SQLite Adapter
+ *
+ * Provides SQLite database in the browser using sql.js WASM.
+ *
+ * @example
+ * ```ts
+ * const adapter = new SqliteAdapter({ storageKey: 'myapp' });
+ * await adapter.connect();
+ * const users = await adapter.list('users');
+ * ```
+ */
+export declare class SqliteAdapter implements IDataAdapter {
+    private db;
+    private SQL;
+    private config;
+    schema?: SchemaDefinition;
+    defaultLang?: string;
+    constructor(config?: SqliteAdapterConfig);
+    setSchema(schema: SchemaDefinition): void;
+    connect(): Promise<void>;
+    private persist;
+    private getDb;
+    private runQuery;
+    /**
+     * Deserialize rows using schema field definitions (bool 0/1 → boolean, json TEXT → parsed)
+     */
+    private deserializeResults;
+    /**
+     * Serialize data for DB storage (bool → 0/1, json → TEXT)
+     */
+    private serializeData;
+    private buildSelectQuery;
+    /**
+     * List records from a table
+     */
+    list<T = unknown>(table: string, options?: QueryOptions): Promise<T[]>;
+    private listWithLang;
+    /**
+     * Get a single record by ID
+     */
+    get<T = unknown>(table: string, id: number | string, options?: {
+        lang?: string;
+        fallbackLang?: string;
+    }): Promise<T | null>;
+    findOne<T = unknown>(table: string, options?: {
+        where?: Record<string, unknown>;
+        lang?: string;
+        fallbackLang?: string;
+    }): Promise<T | null>;
+    private getWithLang;
+    /**
+     * Count records in a table
+     */
+    count(table: string, options?: QueryOptions): Promise<number>;
+    /**
+     * Paginate records
+     */
+    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>;
+    /**
+     * Create a record with explicit translations
+     */
+    createWithTranslations<T = unknown>(table: string, data: Record<string, unknown>, translations?: Record<string, Record<string, unknown>>): Promise<T>;
+    /**
+     * Update a record by ID
+     */
+    update<T = unknown>(table: string, id: number | string, data: Record<string, unknown>): Promise<T>;
+    /**
+     * Upsert a translation for a record
+     */
+    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[]>;
+    /**
+     * Delete a record by ID
+     */
+    delete(table: string, id: number | string): Promise<boolean>;
+    /**
+     * Execute a raw SQL statement
+     */
+    execute(query: string, params?: unknown[]): Promise<{
+        changes: number;
+        lastInsertRowid: number | bigint;
+    }>;
+    /**
+     * Execute a raw SQL query and return results
+     */
+    raw<T = unknown>(query: string, params?: unknown[]): Promise<T[]>;
+    /**
+     * Seed database with initial 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 the database connection
+     */
+    close(): void;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    createMany<T = unknown>(table: string, records: Record<string, unknown>[], options?: {
+        ignore?: boolean;
+    }): Promise<{
+        created: number;
+        ids: (number | bigint)[];
+    }>;
+    updateMany(table: string, updates: {
+        id: number | string;
+        data: Record<string, unknown>;
+    }[]): Promise<{
+        updated: number;
+    }>;
+    deleteMany(table: string, ids: (number | string)[]): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Export database as Uint8Array
+     */
+    export(): Uint8Array;
+    /**
+     * Import database from Uint8Array
+     */
+    import(data: Uint8Array): Promise<void>;
+    /**
+     * Clear all data and reset database
+     */
+    clear(): void;
+}
+//# sourceMappingURL=SqliteAdapter.d.ts.map

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
   });
 }
@@ -636,7 +662,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.3",
   "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.3"
   },
   "devDependencies": {
     "@tanstack/query-core": "5.90.20",

package/SKILL.md

@@ -1,311 +0,0 @@
----
-name: dbreact
-description: |
-  React hooks and providers for schema-driven multi-language databases (@promakeai/dbreact).
-  Use when: integrating React apps with SQLite database, using DbProvider setup,
-  data hooks (useDbList, useDbGet, useDbCreate, useDbUpdate, useDbDelete),
-  language switching (useDbLang), SqliteAdapter for browser, React Query patterns,
-  or any @promakeai/dbreact task.
----
-
-# dbreact - React Database Integration
-
-## Installation
-
-```bash
-npm install @promakeai/dbreact @promakeai/orm @tanstack/react-query sql.js
-```
-
-Peer dependencies: `react >= 18`, `react-dom >= 18`, `@tanstack/react-query >= 5`
-
----
-
-## Quick Setup
-
-```tsx
-import { DbProvider, SqliteAdapter, parseJSONSchema } from '@promakeai/dbreact';
-import schema from './db/schema.json';
-
-const adapter = new SqliteAdapter({
-  storageKey: 'myapp',
-  schema: parseJSONSchema(schema),
-  defaultLang: 'en',
-});
-
-function App() {
-  return (
-    <DbProvider adapter={adapter} lang="en" fallbackLang="en">
-      <YourApp />
-    </DbProvider>
-  );
-}
-```
-
----
-
-## DbProvider Props
-
-```tsx
-interface DbProviderProps {
-  adapter: IDataAdapter;       // Required: SqliteAdapter instance
-  lang?: string;               // Current language (default: 'en')
-  fallbackLang?: string;       // Fallback if translation missing (default: 'en')
-  autoConnect?: boolean;       // Auto-connect on mount (default: true)
-  queryClient?: QueryClient;   // Custom React Query client (optional)
-}
-```
-
-Language changes automatically invalidate all queries and refetch with new language.
-
----
-
-## SqliteAdapter Config
-
-```tsx
-const adapter = new SqliteAdapter({
-  storageKey: 'myapp',           // localStorage key
-  schema: parsedSchema,          // For translation support
-  defaultLang: 'en',             // Default language
-  initialData?: Uint8Array,      // Seed with existing DB
-  wasmPath?: string,             // Custom sql.js WASM path
-});
-```
-
-### Loading Existing Database
-
-```tsx
-// Load from base64 file
-const response = await fetch('/app.db.b64');
-const base64 = await response.text();
-const bytes = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
-
-const adapter = new SqliteAdapter({
-  storageKey: 'myapp',
-  initialData: bytes,
-  schema: parseJSONSchema(schema),
-});
-```
-
----
-
-## Data Hooks
-
-### useDbList<T>(table, options?)
-
-Query multiple records.
-
-```tsx
-interface ListOptions {
-  where?: Record<string, unknown>;  // MongoDB-style filter
-  orderBy?: Array<{ field: string; direction: 'ASC' | 'DESC' }>;
-  limit?: number;
-  offset?: number;
-  enabled?: boolean;  // Conditional query
-}
-
-function ProductList() {
-  const { data, isLoading, error } = useDbList<Product>('products', {
-    where: { stock: { $gt: 0 } },
-    orderBy: [{ field: 'name', direction: 'ASC' }],
-    limit: 10,
-  });
-
-  if (isLoading) return <div>Loading...</div>;
-  if (error) return <div>Error: {error.message}</div>;
-
-  return <ul>{data?.map(p => <li key={p.id}>{p.name}</li>)}</ul>;
-}
-```
-
-### useDbGet<T>(table, id, options?)
-
-Fetch single record by ID.
-
-```tsx
-function ProductDetail({ id }: { id: number }) {
-  const { data: product, isLoading } = useDbGet<Product>('products', id);
-
-  if (isLoading) return <div>Loading...</div>;
-  if (!product) return <div>Not found</div>;
-
-  return <div>{product.name} - ${product.price}</div>;
-}
-```
-
-### useDbCreate<T>(table)
-
-Create new record.
-
-```tsx
-function CreateProduct() {
-  const mutation = useDbCreate<Product>('products');
-
-  const handleCreate = () => {
-    mutation.mutate({ name: 'New Product', price: 99 });
-  };
-
-  return (
-    <button onClick={handleCreate} disabled={mutation.isPending}>
-      {mutation.isPending ? 'Creating...' : 'Create'}
-    </button>
-  );
-}
-```
-
-### useDbUpdate<T>(table)
-
-Update existing record.
-
-```tsx
-function EditProduct({ id }: { id: number }) {
-  const mutation = useDbUpdate<Product>('products');
-
-  const handleUpdate = () => {
-    mutation.mutate({ id, data: { price: 149 } });
-  };
-
-  return <button onClick={handleUpdate}>Update Price</button>;
-}
-```
-
-### useDbDelete(table)
-
-Delete record by ID.
-
-```tsx
-function DeleteProduct({ id }: { id: number }) {
-  const mutation = useDbDelete('products');
-
-  return (
-    <button onClick={() => mutation.mutate(id)}>
-      {mutation.isPending ? 'Deleting...' : 'Delete'}
-    </button>
-  );
-}
-```
-
----
-
-## Language Hook
-
-### useDbLang()
-
-Access and change current language.
-
-```tsx
-function LanguageSwitcher() {
-  const { lang, setLang } = useDbLang();
-
-  return (
-    <select value={lang} onChange={(e) => setLang(e.target.value)}>
-      <option value="en">English</option>
-      <option value="tr">Turkish</option>
-      <option value="de">German</option>
-    </select>
-  );
-}
-```
-
-When `setLang()` is called:
-1. Provider state updates
-2. All queries invalidated
-3. Queries refetch with new language
-4. UI updates automatically
-
----
-
-## Context Hooks
-
-### useDb()
-
-Access connection state.
-
-```tsx
-const { adapter, isConnected, error } = useDb();
-```
-
-### useAdapter()
-
-Direct adapter access for advanced operations.
-
-```tsx
-const adapter = useAdapter();
-await adapter.createWithTranslations('products', data, translations);
-```
-
----
-
-## Query Operators
-
-Same MongoDB-style operators as dbcli:
-
-```tsx
-useDbList('products', {
-  where: {
-    $and: [
-      { price: { $between: [50, 500] } },
-      { stock: { $gt: 0 } },
-      { categoryId: { $in: [1, 5, 10] } },
-      { $or: [{ active: true }, { featured: true }] }
-    ]
-  }
-});
-```
-
-Operators: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$like`, `$notLike`, `$between`, `$isNull`, `$and`, `$or`, `$nor`, `$not`
-
----
-
-## Type Definitions
-
-Use generated types from `dbcli generate`:
-
-```tsx
-// src/db/types.ts (generated)
-export interface DbProduct {
-  id: number;
-  name: string;
-  price: number;
-  stock: number;
-}
-
-// Usage
-const { data } = useDbList<DbProduct>('products');
-const mutation = useDbCreate<DbProduct>('products');
-```
-
----
-
-## Best Practices
-
-1. **Single DbProvider at root** - Don't nest providers
-2. **Use generated types** - Type safety with `DbXxx` interfaces
-3. **Conditional queries** - Use `enabled: false` to prevent unwanted fetches
-4. **Handle all states** - Check `isLoading`, `error`, and empty data
-5. **Language via hook** - Use `setLang()` not prop changes for proper invalidation
-6. **Batch with adapter** - Use `adapter.createMany()` for bulk operations
-7. **Check connection** - Use `useDb().isConnected` before critical operations
-
----
-
-## Exports
-
-```tsx
-// Provider & Context
-export { DbProvider, useDb, useAdapter, useDbLang };
-
-// Data Hooks
-export { useDbList, useDbGet, useDbCreate, useDbUpdate, useDbDelete };
-
-// Adapter
-export { SqliteAdapter };
-
-// Schema
-export { parseJSONSchema, defineSchema, f };
-
-// Query Utilities
-export { buildWhereClause };
-
-// Types
-export type { DbProviderConfig, DbContextValue, DbLangContextValue, ListOptions };
-```

package/providers/DbProvider.tsx

@@ -1,191 +0,0 @@
-/**
- * Database Provider
- *
- * React context provider for database operations with language support.
- */
-
-import {
-  createContext,
-  useContext,
-  useState,
-  useEffect,
-  useMemo,
-  useCallback,
-  useRef,
-  type ReactNode,
-} from "react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import type {
-  IDataAdapter,
-  DbProviderConfig,
-  DbLangContextValue,
-  DbContextValue,
-} from "../types";
-
-// Database context
-const DbContext = createContext<DbContextValue | null>(null);
-
-// Language context
-const DbLangContext = createContext<DbLangContextValue | null>(null);
-
-/**
- * Default QueryClient for React Query
- */
-const defaultQueryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 1000 * 60 * 5, // 5 minutes
-      gcTime: 1000 * 60 * 30, // 30 minutes (formerly cacheTime)
-      refetchOnWindowFocus: false,
-    },
-  },
-});
-
-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 function DbProvider({
-  adapter,
-  lang: langProp = "en",
-  fallbackLang = "en",
-  autoConnect = true,
-  queryClient = defaultQueryClient,
-  children,
-}: DbProviderProps) {
-  const [isConnected, setIsConnected] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
-  const [lang, setLangState] = useState(langProp);
-  const isFirstRender = useRef(true);
-
-  // Sync internal state when prop changes
-  useEffect(() => {
-    if (langProp !== lang) {
-      setLangState(langProp);
-    }
-  }, [langProp]);
-
-  // Invalidate all queries when language changes (skip first render)
-  useEffect(() => {
-    if (isFirstRender.current) {
-      isFirstRender.current = false;
-      return;
-    }
-    // Invalidate all queries to refetch with new language
-    queryClient.invalidateQueries();
-  }, [lang]);
-
-  // Connect to adapter on mount
-  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]);
-
-  // setLang updates internal state (and triggers invalidation via effect)
-  const setLang = useCallback((newLang: string) => {
-    setLangState(newLang);
-  }, []);
-
-  // Database context value
-  const dbContextValue = useMemo<DbContextValue>(
-    () => ({
-      adapter,
-      isConnected,
-      error,
-    }),
-    [adapter, isConnected, error]
-  );
-
-  // Language context value
-  const langContextValue = useMemo<DbLangContextValue>(
-    () => ({
-      lang,
-      fallbackLang,
-      setLang,
-    }),
-    [lang, fallbackLang, setLang]
-  );
-
-  return (
-    <QueryClientProvider client={queryClient}>
-      <DbContext.Provider value={dbContextValue}>
-        <DbLangContext.Provider value={langContextValue}>
-          {children}
-        </DbLangContext.Provider>
-      </DbContext.Provider>
-    </QueryClientProvider>
-  );
-}
-
-/**
- * Hook to access database context
- */
-export function useDb(): DbContextValue {
-  const context = useContext(DbContext);
-  if (!context) {
-    throw new Error("useDb must be used within a DbProvider");
-  }
-  return context;
-}
-
-/**
- * Hook to access the raw adapter
- */
-export function useAdapter(): IDataAdapter {
-  const { adapter } = useDb();
-  return adapter;
-}
-
-/**
- * Hook to access language context
- */
-export function useDbLang(): DbLangContextValue {
-  const context = useContext(DbLangContext);
-  if (!context) {
-    throw new Error("useDbLang must be used within a DbProvider");
-  }
-  return context;
-}