@geenius/db 0.2.0

package/LICENSE

@@ -0,0 +1 @@
+MIT License — © Antigravity HQ

package/README.md

@@ -0,0 +1,164 @@
+# `@geenius/db`
+
+> Multi-provider database adapter implementations for the Geenius ecosystem.
+
+---
+
+## Overview
+
+`@geenius/db` provides real database provider implementations that conform to the `DbAdapter` interface from `@geenius/adapters-shared`. This is the package you use when you need to connect to an actual database.
+
+### Providers
+
+| Provider | Factory | SDK |
+|----------|---------|-----|
+| **Convex** | `createConvexDbAdapter()` | `convex` |
+| **Supabase** | `createSupabaseDbAdapter()` | `@supabase/supabase-js` |
+| **Neon (Drizzle)** | `createNeonDbAdapter()` | `@neondatabase/serverless` + `drizzle-orm` |
+| **MongoDB** | `createMongoDbAdapter()` | `mongodb` |
+| **Cloudflare KV** | `createCloudflareKVDbAdapter()` | `@cloudflare/workers-types` |
+| **In-Memory** | `createMemoryDbAdapter()` | *(none)* |
+
+> For localStorage-based prototyping (Pronto tier), use `createLocalStorageDbAdapter()` from `@geenius/adapters`.
+
+---
+
+## Installation
+
+```bash
+pnpm add @geenius/db
+```
+
+## Sub-package Exports
+
+```typescript
+import { createConvexDbAdapter, createSupabaseDbAdapter } from '@geenius/db'          // shared
+import { DbProvider, useDb }                                from '@geenius/db/react'   // React hooks
+import { DbProvider, createDb }                             from '@geenius/db/solidjs' // SolidJS primitives
+```
+
+---
+
+## Quick Start
+
+### Convex
+
+```typescript
+import { createConvexDbAdapter } from '@geenius/db'
+
+const db = createConvexDbAdapter({
+  client: convexClient,
+  functions: {
+    create: api.adapters.create,
+    get: api.adapters.get,
+    update: api.adapters.update,
+    delete: api.adapters.delete,
+    list: api.adapters.list,
+    query: api.adapters.query,
+    count: api.adapters.count,
+  },
+})
+```
+
+### Supabase
+
+```typescript
+import { createSupabaseDbAdapter } from '@geenius/db'
+
+const db = createSupabaseDbAdapter({
+  supabaseUrl: process.env.SUPABASE_URL!,
+  supabaseKey: process.env.SUPABASE_ANON_KEY!,
+})
+```
+
+### Neon (Drizzle)
+
+```typescript
+import { createNeonDbAdapter } from '@geenius/db'
+import { eq, and, gt, like } from 'drizzle-orm'
+
+const db = createNeonDbAdapter({
+  connectionString: process.env.DATABASE_URL!,
+  schema: myDrizzleSchema,
+  operators: { eq, and, gt, like, or, ne, lt, lte, gte, sql },
+})
+```
+
+### MongoDB
+
+```typescript
+import { createMongoDbAdapter } from '@geenius/db'
+
+const db = createMongoDbAdapter({
+  uri: process.env.MONGODB_URI!,
+  dbName: 'my-app',
+})
+```
+
+### React Provider
+
+```tsx
+import { DbProvider, useDb } from '@geenius/db/react'
+import { createConvexDbAdapter } from '@geenius/db'
+
+function App() {
+  const db = createConvexDbAdapter({ ... })
+  return (
+    <DbProvider adapter={db}>
+      <MyComponent />
+    </DbProvider>
+  )
+}
+
+function MyComponent() {
+  const db = useDb()
+  // db.list('users'), db.create('users', { name: '...' }), etc.
+}
+```
+
+### SolidJS Provider
+
+```tsx
+import { DbProvider, createDb } from '@geenius/db/solidjs'
+import { createConvexDbAdapter } from '@geenius/db'
+
+function App() {
+  const db = createConvexDbAdapter({ ... })
+  return (
+    <DbProvider adapter={db}>
+      <MyComponent />
+    </DbProvider>
+  )
+}
+
+function MyComponent() {
+  const db = createDb()
+  // db.list('users'), db.create('users', { name: '...' }), etc.
+}
+```
+
+---
+
+## Architecture
+
+This package implements the `DbAdapter` interface defined in `@geenius/adapters-shared`:
+
+```typescript
+interface DbAdapter {
+  create<T>(collection: string, data: Omit<T, 'id'>): Promise<T & { id: string }>
+  get<T>(collection: string, id: string): Promise<T | null>
+  update<T>(collection: string, id: string, data: Partial<T>): Promise<T | null>
+  delete(collection: string, id: string): Promise<boolean>
+  list<T>(collection: string, options?: ListOptions): Promise<T[]>
+  query<T>(collection: string, filter: QueryFilter): Promise<T[]>
+  count(collection: string, filter?: QueryFilter): Promise<number>
+}
+```
+
+All providers throw `DbError` from `@geenius/adapters-shared` on failure.
+
+---
+
+## License
+
+MIT — © Antigravity HQ

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@geenius/db",
+  "type": "module",
+  "version": "0.2.0",
+  "description": "Geenius DB — Multi-provider database adapter implementations (Convex, Supabase, Neon, MongoDB, CloudflareKV)",
+  "author": "Antigravity HQ",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geenius-dev/geenius-db.git"
+  },
+  "keywords": [
+    "database",
+    "adapter",
+    "convex",
+    "supabase",
+    "neon",
+    "mongodb",
+    "cloudflare-kv",
+    "react",
+    "solidjs",
+    "geenius"
+  ],
+  "scripts": {
+    "dev": "pnpm -r --parallel type-check",
+    "build": "pnpm -r build",
+    "clean": "pnpm -r clean",
+    "lint": "pnpm -r --parallel type-check",
+    "test": "echo \"No tests configured yet\" && exit 0",
+    "type-check": "pnpm -r type-check",
+    "format": "prettier --write \"packages/*/src/**/*.{ts,tsx}\"",
+    "version:patch": "pnpm -r exec -- npm version patch --no-git-tag-version && npm version patch -m 'v%s'",
+    "version:minor": "pnpm -r exec -- npm version minor --no-git-tag-version && npm version minor -m 'v%s'",
+    "version:major": "pnpm -r exec -- npm version major --no-git-tag-version && npm version major -m 'v%s'",
+    "release": "git push && git push --tags",
+    "publish:all": "pnpm -r publish --access public"
+  },
+  "devDependencies": {
+    "prettier": "^3.8.1",
+    "typescript": "~6.0.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./packages/shared/dist/index.d.ts",
+      "import": "./packages/shared/dist/index.js"
+    },
+    "./shared": {
+      "types": "./packages/shared/dist/index.d.ts",
+      "import": "./packages/shared/dist/index.js"
+    },
+    "./react": {
+      "types": "./packages/react/dist/index.d.ts",
+      "import": "./packages/react/dist/index.js"
+    },
+    "./solidjs": {
+      "types": "./packages/solidjs/dist/index.d.ts",
+      "import": "./packages/solidjs/dist/index.js"
+    }
+  },
+  "main": "./packages/shared/dist/index.js",
+  "types": "./packages/shared/dist/index.d.ts"
+}

package/packages/react/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@geenius/db-react",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "description": "Geenius DB — React hooks and providers for database adapters",
+  "author": "Antigravity HQ",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm clean && pnpm build"
+  },
+  "peerDependencies": {
+    "@geenius/adapters-shared": ">=0.2.0",
+    "@geenius/db-shared": ">=0.2.0",
+    "react": ">=19.0.0"
+  },
+  "devDependencies": {
+    "@geenius/adapters-shared": "link:../../../geenius-adapters/packages/shared",
+    "@geenius/db-shared": "workspace:*",
+    "@types/react": "^19.1.4",
+    "react": "^19.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "~6.0.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/packages/react/src/index.tsx

@@ -0,0 +1,82 @@
+// @geenius/db-react — React hooks and providers for database adapters
+
+'use client'
+
+import { createContext, useContext, useMemo, type ReactNode } from 'react'
+import type { DbAdapter } from '@geenius/adapters-shared'
+
+// ─── Context ─────────────────────────────────────────────────────────────────
+
+const DbContext = createContext<DbAdapter | null>(null)
+
+// ─── Provider ────────────────────────────────────────────────────────────────
+
+export interface DbProviderProps {
+  adapter: DbAdapter
+  children: ReactNode
+}
+
+/**
+ * Provides a DbAdapter instance to all child components via React context.
+ *
+ * @example
+ * ```tsx
+ * import { DbProvider } from '@geenius/db/react'
+ * import { createConvexDbAdapter } from '@geenius/db'
+ *
+ * function App() {
+ *   const db = createConvexDbAdapter({ client: convex, functions: myFns })
+ *   return (
+ *     <DbProvider adapter={db}>
+ *       <Router />
+ *     </DbProvider>
+ *   )
+ * }
+ * ```
+ */
+export function DbProvider({ adapter, children }: DbProviderProps) {
+  const value = useMemo(() => adapter, [adapter])
+  return <DbContext.Provider value={value}>{children}</DbContext.Provider>
+}
+
+// ─── Hooks ───────────────────────────────────────────────────────────────────
+
+/**
+ * Access the DbAdapter from context.
+ *
+ * @throws Error if used outside of a `<DbProvider>`
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const db = useDb()
+ *   const [users, setUsers] = useState([])
+ *
+ *   useEffect(() => {
+ *     db.list('users').then(setUsers)
+ *   }, [db])
+ * }
+ * ```
+ */
+export function useDb(): DbAdapter {
+  const ctx = useContext(DbContext)
+  if (!ctx) {
+    throw new Error(
+      '[@geenius/db] useDb() must be used inside a <DbProvider>. '
+      + 'Wrap your app with <DbProvider adapter={...}>.',
+    )
+  }
+  return ctx
+}
+
+/**
+ * Access the DbAdapter from context, returning null if not available.
+ * Useful for optional DB access in shared components.
+ */
+export function useDbOptional(): DbAdapter | null {
+  return useContext(DbContext)
+}
+
+// ─── Re-exports ──────────────────────────────────────────────────────────────
+
+export type { DbAdapter } from '@geenius/adapters-shared'

package/packages/react/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "outDir": "dist",
+    "rootDir": "src",
+    "jsx": "react-jsx"
+  },
+  "include": ["src"]
+}

package/packages/react/tsup.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: { index: 'src/index.tsx' },
+    outDir: 'dist',
+    format: ['esm'],
+    dts: true,
+    sourcemap: true,
+    clean: true,
+    treeshake: true,
+    external: [
+        '@geenius/adapters-shared',
+        '@geenius/db-shared',
+        'react',
+        'react/jsx-runtime',
+    ],
+})

package/packages/shared/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@geenius/db-shared",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "description": "Geenius DB — Database provider implementations (Convex, Supabase, Neon, MongoDB, CloudflareKV)",
+  "author": "Antigravity HQ",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit",
+    "prepublishOnly": "pnpm clean && pnpm build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "peerDependencies": {
+    "@geenius/adapters-shared": ">=0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@geenius/adapters-shared": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@geenius/adapters-shared": "link:../../../geenius-adapters/packages/shared",
+    "@neondatabase/serverless": "^1.0.2",
+    "@supabase/supabase-js": "^2.101.1",
+    "convex": "^1.34.1",
+    "mongodb": "^7.1.1",
+    "tsup": "^8.5.1",
+    "typescript": "~6.0.2",
+    "vitest": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,42 @@
+// @geenius/db-shared — src/index.ts
+//
+// Database provider implementations for the Geenius ecosystem.
+// All providers implement the DbAdapter interface from @geenius/adapters-shared.
+//
+// Usage:
+//   import { createConvexDbAdapter } from '@geenius/db'
+//   import { createSupabaseDbAdapter } from '@geenius/db'
+//   import type { DbAdapter } from '@geenius/adapters-shared'
+
+// ─── Re-export DbAdapter interface from @geenius/adapters-shared ─────────────
+// Consumers can import the interface directly from this package for convenience.
+
+export type {
+  DbAdapter,
+  ListOptions,
+  QueryOperator,
+  QueryCondition,
+  QueryFilter,
+} from '@geenius/adapters-shared'
+
+export { DbError } from '@geenius/adapters-shared'
+export type { DbErrorCode } from '@geenius/adapters-shared'
+
+// ─── Provider Implementations ────────────────────────────────────────────────
+
+export { createConvexDbAdapter } from './providers/convex'
+export type { ConvexDbAdapterOptions } from './providers/convex'
+
+export { createSupabaseDbAdapter } from './providers/supabase'
+export type { SupabaseDbAdapterOptions } from './providers/supabase'
+
+export { createNeonDbAdapter } from './providers/neon'
+export type { NeonDbAdapterOptions, DrizzleOperators } from './providers/neon'
+
+export { createMongoDbAdapter } from './providers/mongodb'
+export type { MongoDbAdapterOptions } from './providers/mongodb'
+
+export { createCloudflareKVDbAdapter } from './providers/cloudflareKV'
+export type { KVNamespaceLike } from './providers/cloudflareKV'
+
+export { createMemoryDbAdapter } from './providers/memory'

package/packages/shared/src/providers/cloudflareKV.ts

@@ -0,0 +1,110 @@
+// @geenius/adapters — Cloudflare KV DB implementation
+
+import type { ListOptions, QueryFilter, QueryCondition } from '@geenius/adapters-shared'
+import type { DbAdapter } from '@geenius/adapters-shared'
+import { DbError } from '@geenius/adapters-shared'
+
+// Generic typing for the global KVNamespace if @cloudflare/workers-types isn't explicitly imported
+export interface KVNamespaceLike {
+  get(key: string, type: 'json'): Promise<unknown>
+  put(key: string, value: string): Promise<void>
+}
+
+const DB_PREFIX = 'geenius_db_'
+
+function matchesCondition(item: Record<string, unknown>, cond: QueryCondition): boolean {
+  const val = item[cond.field]
+  switch (cond.operator) {
+    case 'eq': return val === cond.value
+    case 'neq': return val !== cond.value
+    case 'gt': return (val as number) > (cond.value as number)
+    case 'gte': return (val as number) >= (cond.value as number)
+    case 'lt': return (val as number) < (cond.value as number)
+    case 'lte': return (val as number) <= (cond.value as number)
+    case 'in': return Array.isArray(cond.value) && cond.value.includes(val)
+    case 'contains': return typeof val === 'string' && val.includes(cond.value as string)
+    default: return false
+  }
+}
+
+function matchesFilter(item: Record<string, unknown>, filter: QueryFilter): boolean {
+  return filter.every(cond => matchesCondition(item, cond))
+}
+
+export function createCloudflareKVDbAdapter(kv: KVNamespaceLike): DbAdapter {
+  async function getCollection(collection: string): Promise<Record<string, unknown>[]> {
+    try {
+      const data = await kv.get(DB_PREFIX + collection, 'json')
+      return (data as Record<string, unknown>[]) || []
+    } catch (err) {
+      throw new DbError(`Failed to read collection "${collection}" from KV`, 'CONNECTION_ERROR', err)
+    }
+  }
+
+  async function saveCollection(collection: string, data: Record<string, unknown>[]): Promise<void> {
+    try {
+      await kv.put(DB_PREFIX + collection, JSON.stringify(data))
+    } catch (err) {
+      throw new DbError(`Failed to write collection "${collection}" to KV`, 'CONNECTION_ERROR', err)
+    }
+  }
+
+  return {
+    async create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>) {
+      const items = await getCollection(collection)
+      const item = { ...data, id: crypto.randomUUID() }
+      items.push(item)
+      await saveCollection(collection, items)
+      return item as T & { id: string }
+    },
+
+    async get<T>(collection: string, id: string) {
+      const items = await getCollection(collection)
+      const found = items.find(item => item.id === id)
+      return (found as T | undefined) ?? null
+    },
+
+    async update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>) {
+      const items = await getCollection(collection)
+      const idx = items.findIndex(item => item.id === id)
+      if (idx === -1) return null
+      Object.assign(items[idx], data)
+      await saveCollection(collection, items)
+      return items[idx] as T | null
+    },
+
+    async delete(collection: string, id: string) {
+      const items = await getCollection(collection)
+      const idx = items.findIndex(item => item.id === id)
+      if (idx === -1) return false
+      items.splice(idx, 1)
+      await saveCollection(collection, items)
+      return true
+    },
+
+    async list<T>(collection: string, options?: ListOptions) {
+      let items = await getCollection(collection)
+      if (options?.orderBy) {
+        const dir = options.order === 'desc' ? -1 : 1
+        items.sort((a, b) => {
+          const av = a[options.orderBy!] as string | number, bv = b[options.orderBy!] as string | number
+          return av < bv ? -dir : av > bv ? dir : 0
+        })
+      }
+      if (options?.offset) items = items.slice(options.offset)
+      if (options?.limit) items = items.slice(0, options.limit)
+      return items as T[]
+    },
+
+    async query<T>(collection: string, filter: QueryFilter) {
+      const items = await getCollection(collection)
+      return items.filter(item => matchesFilter(item, filter)) as T[]
+    },
+
+    async count(collection: string, filter?: QueryFilter) {
+      const items = await getCollection(collection)
+      if (!filter || filter.length === 0) return items.length
+      return items.filter(item => matchesFilter(item, filter)).length
+    },
+  }
+}