@geenius/db 0.2.0

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

@@ -0,0 +1,160 @@
+// @geenius/adapters — Supabase DB implementation (MVP tier)
+// Wraps the Supabase client to conform to DbAdapter interface.
+// Requires: @supabase/supabase-js
+
+import type { ListOptions, QueryFilter } from '@geenius/adapters-shared'
+import type { DbAdapter } from '@geenius/adapters-shared'
+import { DbError } from '@geenius/adapters-shared'
+
+interface SupabaseClient {
+  from: (table: string) => SupabaseQueryBuilder
+}
+
+interface SupabaseQueryBuilder {
+  select: (columns?: string) => SupabaseQueryBuilder
+  insert: (data: Record<string, unknown>) => SupabaseQueryBuilder
+  update: (data: Record<string, unknown>) => SupabaseQueryBuilder
+  delete: () => SupabaseQueryBuilder
+  eq: (column: string, value: unknown) => SupabaseQueryBuilder
+  neq: (column: string, value: unknown) => SupabaseQueryBuilder
+  gt: (column: string, value: unknown) => SupabaseQueryBuilder
+  gte: (column: string, value: unknown) => SupabaseQueryBuilder
+  lt: (column: string, value: unknown) => SupabaseQueryBuilder
+  lte: (column: string, value: unknown) => SupabaseQueryBuilder
+  in: (column: string, values: unknown[]) => SupabaseQueryBuilder
+  ilike: (column: string, pattern: string) => SupabaseQueryBuilder
+  order: (column: string, options?: { ascending?: boolean }) => SupabaseQueryBuilder
+  range: (from: number, to: number) => SupabaseQueryBuilder
+  limit: (count: number) => SupabaseQueryBuilder
+  single: () => SupabaseQueryBuilder
+  then: (resolve: (value: { data: unknown; error: { message: string } | null }) => void) => Promise<unknown>
+}
+
+export interface SupabaseDbAdapterOptions {
+  /** Pre-configured Supabase client instance */
+  client: SupabaseClient
+  /** Optional table name mapping: { collectionName: 'actual_table_name' } */
+  tableNames?: Record<string, string>
+}
+
+/**
+ * Creates a Supabase-backed DbAdapter.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from '@supabase/supabase-js'
+ *
+ * const supabase = createClient(url, key)
+ * const db = createSupabaseDbAdapter({ client: supabase })
+ * ```
+ */
+export function createSupabaseDbAdapter(options: SupabaseDbAdapterOptions): DbAdapter {
+  const { client, tableNames = {} } = options
+
+  function tableName(collection: string): string {
+    return tableNames[collection] || collection
+  }
+
+  // Supabase query builder returns { data, error } — the builder chain is
+  // thenable, so we await it directly. The intermediate chain types don't
+  // carry our generic T, so we cast at the result boundary.
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  return {
+    async create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>) {
+      const { data: result, error } = await (client
+        .from(tableName(collection))
+        .insert(data as Record<string, unknown>)
+        .select()
+        .single() as any)
+
+      if (error) throw new DbError(`Insert into "${collection}" failed: ${error.message}`, 'QUERY_ERROR', error)
+      return result as T & { id: string }
+    },
+
+    async get<T>(collection: string, id: string) {
+      const { data, error } = await (client
+        .from(tableName(collection))
+        .select()
+        .eq('id', id)
+        .single() as any)
+
+      if (error) return null
+      return data as T
+    },
+
+    async update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>) {
+      const { data: result, error } = await (client
+        .from(tableName(collection))
+        .update(data as Record<string, unknown>)
+        .eq('id', id)
+        .select()
+        .single() as any)
+
+      if (error) return null
+      return result as T
+    },
+
+    async delete(collection: string, id: string) {
+      const { error } = await (client
+        .from(tableName(collection))
+        .delete()
+        .eq('id', id) as any)
+
+      return !error
+    },
+
+    async list<T>(collection: string, options?: ListOptions) {
+      let query: any = client.from(tableName(collection)).select()
+
+      if (options?.orderBy) {
+        query = query.order(options.orderBy, {
+          ascending: options.order !== 'desc',
+        })
+      }
+
+      if (options?.offset !== undefined && options?.limit !== undefined) {
+        query = query.range(options.offset, options.offset + options.limit - 1)
+      } else if (options?.limit) {
+        query = query.limit(options.limit)
+      }
+
+      const { data, error } = await query
+      if (error) throw new DbError(`List "${collection}" failed: ${error.message}`, 'QUERY_ERROR', error)
+      return (data || []) as T[]
+    },
+
+    async query<T>(collection: string, filter: QueryFilter) {
+      let query: any = client.from(tableName(collection)).select()
+
+      for (const cond of filter) {
+        switch (cond.operator) {
+          case 'eq': query = query.eq(cond.field, cond.value); break
+          case 'neq': query = query.neq(cond.field, cond.value); break
+          case 'gt': query = query.gt(cond.field, cond.value); break
+          case 'gte': query = query.gte(cond.field, cond.value); break
+          case 'lt': query = query.lt(cond.field, cond.value); break
+          case 'lte': query = query.lte(cond.field, cond.value); break
+          case 'in': query = query.in(cond.field, cond.value as unknown[]); break
+          case 'contains': query = query.ilike(cond.field, `%${cond.value}%`); break
+        }
+      }
+
+      const { data, error } = await query
+      if (error) throw new DbError(`Query "${collection}" failed: ${error.message}`, 'QUERY_ERROR', error)
+      return (data || []) as T[]
+    },
+
+    async count(collection: string, filter?: QueryFilter) {
+      if (!filter || filter.length === 0) {
+        const { data } = await (client
+          .from(tableName(collection))
+          .select('id') as any)
+        return data?.length ?? 0
+      }
+
+      const items = await this.query(collection, filter)
+      return items.length
+    },
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+}

package/packages/shared/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": [
+    "src"
+  ]
+}

package/packages/shared/tsup.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: { index: 'src/index.ts' },
+    outDir: 'dist',
+    format: ['esm'],
+    dts: true,
+    sourcemap: true,
+    clean: true,
+    treeshake: true,
+    external: [
+        '@geenius/adapters-shared',
+        '@neondatabase/serverless',
+        '@supabase/supabase-js',
+        'convex',
+        'mongodb',
+    ],
+})

package/packages/solidjs/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@geenius/db-solidjs",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "description": "Geenius DB — SolidJS primitives 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",
+    "solid-js": ">=1.9.0"
+  },
+  "devDependencies": {
+    "@geenius/adapters-shared": "link:../../../geenius-adapters/packages/shared",
+    "@geenius/db-shared": "workspace:*",
+    "solid-js": "^1.9.8",
+    "tsup": "^8.5.1",
+    "typescript": "~6.0.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/packages/solidjs/src/index.tsx

@@ -0,0 +1,83 @@
+// @geenius/db-solidjs — SolidJS primitives and providers for database adapters
+
+import { createContext, useContext, type JSX } from 'solid-js'
+import type { DbAdapter } from '@geenius/adapters-shared'
+
+// ─── Context ─────────────────────────────────────────────────────────────────
+
+const DbContext = createContext<DbAdapter>()
+
+// ─── Provider ────────────────────────────────────────────────────────────────
+
+export interface DbProviderProps {
+  adapter: DbAdapter
+  children: JSX.Element
+}
+
+/**
+ * Provides a DbAdapter instance to all child components via SolidJS context.
+ *
+ * @example
+ * ```tsx
+ * import { DbProvider } from '@geenius/db/solidjs'
+ * import { createConvexDbAdapter } from '@geenius/db'
+ *
+ * function App() {
+ *   const db = createConvexDbAdapter({ client: convex, functions: myFns })
+ *   return (
+ *     <DbProvider adapter={db}>
+ *       <Router />
+ *     </DbProvider>
+ *   )
+ * }
+ * ```
+ */
+export function DbProvider(props: DbProviderProps) {
+  return (
+    <DbContext.Provider value={props.adapter}>
+      {props.children}
+    </DbContext.Provider>
+  )
+}
+
+// ─── Primitives ──────────────────────────────────────────────────────────────
+
+/**
+ * Access the DbAdapter from context.
+ *
+ * @throws Error if used outside of a `<DbProvider>`
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const db = createDb()
+ *   const [users, setUsers] = createSignal([])
+ *
+ *   onMount(async () => {
+ *     setUsers(await db.list('users'))
+ *   })
+ * }
+ * ```
+ */
+export function createDb(): DbAdapter {
+  const ctx = useContext(DbContext)
+  if (!ctx) {
+    throw new Error(
+      '[@geenius/db] createDb() must be used inside a <DbProvider>. '
+      + 'Wrap your app with <DbProvider adapter={...}>.',
+    )
+  }
+  return ctx
+}
+
+/**
+ * Access the DbAdapter from context, returning undefined if not available.
+ * Useful for optional DB access in shared components.
+ */
+export function createDbOptional(): DbAdapter | undefined {
+  return useContext(DbContext)
+}
+
+// ─── Re-exports ──────────────────────────────────────────────────────────────
+
+export type { DbAdapter } from '@geenius/adapters-shared'

package/packages/solidjs/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "outDir": "dist",
+    "rootDir": "src",
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js"
+  },
+  "include": ["src"]
+}

package/packages/solidjs/tsup.config.ts

@@ -0,0 +1,18 @@
+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',
+        'solid-js',
+        'solid-js/web',
+        'solid-js/store',
+    ],
+})

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - 'packages/*'

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "jsx": "react-jsx",
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}