@promakeai/dbreact 1.0.1

package/dist/providers/DbProvider.js

@@ -0,0 +1,134 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Database Provider
+ *
+ * React context provider for database operations with language support.
+ */
+import { createContext, useContext, useState, useEffect, useMemo, useCallback, useRef, } from "react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+// Database context
+const DbContext = createContext(null);
+// Language context
+const DbLangContext = createContext(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,
+        },
+    },
+});
+/**
+ * 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, }) {
+    const [isConnected, setIsConnected] = useState(false);
+    const [error, setError] = useState(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) => {
+        setLangState(newLang);
+    }, []);
+    // Database context value
+    const dbContextValue = useMemo(() => ({
+        adapter,
+        isConnected,
+        error,
+    }), [adapter, isConnected, error]);
+    // Language context value
+    const langContextValue = useMemo(() => ({
+        lang,
+        fallbackLang,
+        setLang,
+    }), [lang, fallbackLang, setLang]);
+    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(DbContext.Provider, { value: dbContextValue, children: _jsx(DbLangContext.Provider, { value: langContextValue, children: children }) }) }));
+}
+/**
+ * Hook to access database context
+ */
+export function useDb() {
+    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() {
+    const { adapter } = useDb();
+    return adapter;
+}
+/**
+ * Hook to access language context
+ */
+export function useDbLang() {
+    const context = useContext(DbLangContext);
+    if (!context) {
+        throw new Error("useDbLang must be used within a DbProvider");
+    }
+    return context;
+}

package/dist/types.d.ts.map

@@ -0,0 +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"}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * dbreact Types
+ *
+ * Re-exports from @promakeai/orm and React-specific types.
+ */
+export {};

package/dist/utils/whereBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whereBuilder.d.ts","sourceRoot":"","sources":["../../utils/whereBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB;AAqHD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,WAAW,CAK7E"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@promakeai/dbreact",
+  "version": "1.0.1",
+  "description": "React client for schema-driven multi-language database",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun build index.ts --outdir dist --target browser --packages=external && 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",
+    "typecheck": "tsc --noEmit",
+    "release": "bun run build && npm publish --access public"
+  },
+  "keywords": [
+    "react",
+    "database",
+    "sqlite",
+    "multi-language",
+    "tanstack-query"
+  ],
+  "author": "Promake Inc.",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0",
+    "@tanstack/react-query": ">=5.0.0",
+    "sql.js": ">=1.11.0"
+  },
+  "dependencies": {
+    "@promakeai/orm": "1.0.1"
+  },
+  "devDependencies": {
+    "@tanstack/query-core": "5.90.20",
+    "@tanstack/react-query": "^5.66.0",
+    "@types/react": "^19.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "sql.js": "^1.12.0",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/providers/DbProvider.tsx

@@ -0,0 +1,191 @@
+/**
+ * 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;
+}