@geenius/db 0.2.0

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

@@ -0,0 +1,151 @@
+// @geenius/adapters — Convex DB implementation (MVP tier)
+// Wraps the Convex client to conform to DbAdapter interface.
+// Requires: convex
+
+import type { ListOptions, QueryFilter } from '@geenius/adapters-shared'
+import type { DbAdapter } from '@geenius/adapters-shared'
+import { DbError } from '@geenius/adapters-shared'
+
+interface ConvexClient {
+  query: (fn: unknown, args?: Record<string, unknown>) => Promise<unknown>
+  mutation: (fn: unknown, args?: Record<string, unknown>) => Promise<unknown>
+}
+
+export interface ConvexDbAdapterOptions {
+  /** Pre-configured Convex client */
+  client: ConvexClient
+  /** Map of collection names to Convex function references */
+  functions: {
+    [collection: string]: {
+      create?: unknown
+      get?: unknown
+      update?: unknown
+      delete?: unknown
+      list?: unknown
+      query?: unknown
+      count?: unknown
+    }
+  }
+}
+
+/**
+ * Creates a Convex-backed DbAdapter.
+ *
+ * Since Convex uses predefined queries/mutations rather than arbitrary SQL,
+ * you must provide function references for each collection. The adapter maps
+ * generic CRUD calls to these Convex functions.
+ *
+ * @example
+ * ```ts
+ * import { api } from '../convex/_generated/api'
+ *
+ * const db = createConvexDbAdapter({
+ *   client: convex,
+ *   functions: {
+ *     tasks: {
+ *       create: api.tasks.create,
+ *       get: api.tasks.get,
+ *       list: api.tasks.list,
+ *       update: api.tasks.update,
+ *       delete: api.tasks.remove,
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export function createConvexDbAdapter(options: ConvexDbAdapterOptions): DbAdapter {
+  const { client, functions } = options
+
+  function getFns(collection: string) {
+    const fns = functions[collection]
+    if (!fns) throw new DbError(`No Convex functions configured for collection: ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+    return fns
+  }
+
+  function matchesFilter(item: Record<string, unknown>, filter: QueryFilter): boolean {
+    return filter.every((cond) => {
+      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
+      }
+    })
+  }
+
+  // Convex query/mutation results are loosely typed — the actual shape depends
+  // on user-defined Convex functions. We cast at the boundary.
+  return {
+    async create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>) {
+      const fns = getFns(collection)
+      if (!fns.create) throw new DbError(`No create function for ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+      const id = await client.mutation(fns.create, data as Record<string, unknown>)
+      return { ...data, id } as T & { id: string }
+    },
+
+    async get<T>(collection: string, id: string) {
+      const fns = getFns(collection)
+      if (!fns.get) throw new DbError(`No get function for ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+      const doc = await client.query(fns.get, { id }) as Record<string, unknown> | null
+      if (!doc) return null
+      return { ...doc, id: (doc._id as string) || id } as T
+    },
+
+    async update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>) {
+      const fns = getFns(collection)
+      if (!fns.update) throw new DbError(`No update function for ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+      await client.mutation(fns.update, { id, ...data } as Record<string, unknown>)
+      return this.get<T>(collection, id)
+    },
+
+    async delete(collection: string, id: string) {
+      const fns = getFns(collection)
+      if (!fns.delete) throw new DbError(`No delete function for ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+      try {
+        await client.mutation(fns.delete, { id })
+        return true
+      } catch (err) {
+        throw new DbError(`Delete from "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+    },
+
+    async list<T>(collection: string, options?: ListOptions) {
+      const fns = getFns(collection)
+      if (!fns.list) throw new DbError(`No list function for ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+      const docs = await client.query(fns.list, {
+        limit: options?.limit,
+        offset: options?.offset,
+        orderBy: options?.orderBy,
+        order: options?.order,
+      }) as Record<string, unknown>[]
+      return (docs || []).map((d) => ({ ...d, id: (d._id as string) || d.id })) as T[]
+    },
+
+    async query<T>(collection: string, filter: QueryFilter) {
+      const fns = getFns(collection)
+      if (!fns.query) {
+        // Fallback: list all and filter client-side
+        const all = await this.list<Record<string, unknown>>(collection)
+        return all.filter((item) => matchesFilter(item, filter)) as T[]
+      }
+      const docs = await client.query(fns.query, { filter }) as Record<string, unknown>[]
+      return (docs || []).map((d) => ({ ...d, id: (d._id as string) || d.id })) as T[]
+    },
+
+    async count(collection: string, filter?: QueryFilter) {
+      const fns = getFns(collection)
+      if (fns.count) {
+        return client.query(fns.count, filter ? { filter } : undefined) as Promise<number>
+      }
+      // Fallback: count via list/query
+      const items = filter ? await this.query(collection, filter) : await this.list(collection)
+      return items.length
+    },
+  }
+}

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

@@ -0,0 +1,92 @@
+// @geenius/adapters — InMemory DB implementation
+
+import type { ListOptions, QueryFilter, QueryCondition } from '@geenius/adapters-shared'
+import type { DbAdapter } from '@geenius/adapters-shared'
+
+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 createMemoryDbAdapter(): DbAdapter {
+  const store = new Map<string, Record<string, unknown>[]>()
+
+  function getCollection(collection: string): Record<string, unknown>[] {
+    return store.get(collection) || []
+  }
+
+  function saveCollection(collection: string, data: Record<string, unknown>[]) {
+    store.set(collection, data)
+  }
+
+  return {
+    async create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>) {
+      const items = getCollection(collection)
+      const item = { ...data, id: crypto.randomUUID() }
+      items.push(item)
+      saveCollection(collection, items)
+      return item as T & { id: string }
+    },
+
+    async get<T>(collection: string, id: string) {
+      const found = getCollection(collection).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 = getCollection(collection)
+      const idx = items.findIndex(item => item.id === id)
+      if (idx === -1) return null
+      Object.assign(items[idx], data)
+      saveCollection(collection, items)
+      return items[idx] as T | null
+    },
+
+    async delete(collection: string, id: string) {
+      const items = getCollection(collection)
+      const idx = items.findIndex(item => item.id === id)
+      if (idx === -1) return false
+      items.splice(idx, 1)
+      saveCollection(collection, items)
+      return true
+    },
+
+    async list<T>(collection: string, options?: ListOptions) {
+      let items = 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) {
+      return getCollection(collection).filter(item => matchesFilter(item, filter)) as T[]
+    },
+
+    async count(collection: string, filter?: QueryFilter) {
+      const items = getCollection(collection)
+      if (!filter || filter.length === 0) return items.length
+      return items.filter(item => matchesFilter(item, filter)).length
+    },
+  }
+}

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

@@ -0,0 +1,137 @@
+// @geenius/adapters — MongoDB implementation (MVP tier)
+// Wraps the MongoDB Node.js driver to conform to DbAdapter interface.
+// Requires: mongodb
+
+import type { ListOptions, QueryFilter } from '@geenius/adapters-shared'
+import type { DbAdapter } from '@geenius/adapters-shared'
+import { DbError } from '@geenius/adapters-shared'
+
+interface MongoCollection {
+  insertOne: (doc: Record<string, unknown>) => Promise<{ insertedId: unknown }>
+  findOne: (filter: Record<string, unknown>) => Promise<Record<string, unknown> | null>
+  updateOne: (filter: Record<string, unknown>, update: Record<string, unknown>) => Promise<unknown>
+  deleteOne: (filter: Record<string, unknown>) => Promise<{ deletedCount: number }>
+  find: (filter?: Record<string, unknown>) => MongoCursor
+  countDocuments: (filter?: Record<string, unknown>) => Promise<number>
+}
+
+interface MongoCursor {
+  sort: (sort: Record<string, number>) => MongoCursor
+  skip: (n: number) => MongoCursor
+  limit: (n: number) => MongoCursor
+  toArray: () => Promise<Record<string, unknown>[]>
+}
+
+interface MongoDb {
+  collection: (name: string) => MongoCollection
+}
+
+export interface MongoDbAdapterOptions {
+  /** Pre-configured MongoDB database instance */
+  db: MongoDb
+  /** Optional collection name mapping */
+  collectionNames?: Record<string, string>
+}
+
+/**
+ * Creates a MongoDB-backed DbAdapter.
+ *
+ * @example
+ * ```ts
+ * import { MongoClient } from 'mongodb'
+ *
+ * const client = new MongoClient(process.env.MONGODB_URI!)
+ * const db = client.db('myapp')
+ * const adapter = createMongoDbAdapter({ db })
+ * ```
+ */
+export function createMongoDbAdapter(options: MongoDbAdapterOptions): DbAdapter {
+  const { db, collectionNames = {} } = options
+
+  function col(collection: string): MongoCollection {
+    return db.collection(collectionNames[collection] || collection)
+  }
+
+  function buildMongoFilter(filter: QueryFilter): Record<string, unknown> {
+    const mongoFilter: Record<string, unknown> = {}
+
+    for (const cond of filter) {
+      switch (cond.operator) {
+        case 'eq': mongoFilter[cond.field] = cond.value; break
+        case 'neq': mongoFilter[cond.field] = { $ne: cond.value }; break
+        case 'gt': mongoFilter[cond.field] = { $gt: cond.value }; break
+        case 'gte': mongoFilter[cond.field] = { $gte: cond.value }; break
+        case 'lt': mongoFilter[cond.field] = { $lt: cond.value }; break
+        case 'lte': mongoFilter[cond.field] = { $lte: cond.value }; break
+        case 'in': mongoFilter[cond.field] = { $in: cond.value }; break
+        case 'contains':
+          mongoFilter[cond.field] = { $regex: cond.value, $options: 'i' }
+          break
+      }
+    }
+
+    return mongoFilter
+  }
+
+  function stripMongoId(doc: Record<string, unknown>): Record<string, unknown> {
+    const { _id, ...rest } = doc
+    return rest
+  }
+
+  return {
+    async create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>) {
+      const id = crypto.randomUUID()
+      const doc = { ...data, id }
+      try {
+        await col(collection).insertOne(doc)
+      } catch (err) {
+        throw new DbError(`Insert into "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+      return doc as T & { id: string }
+    },
+
+    async get<T>(collection: string, id: string) {
+      const doc = await col(collection).findOne({ id })
+      if (!doc) return null
+      return stripMongoId(doc) as T
+    },
+
+    async update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>) {
+      try {
+        await col(collection).updateOne({ id }, { $set: data })
+      } catch (err) {
+        throw new DbError(`Update in "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+      return this.get<T>(collection, id)
+    },
+
+    async delete(collection: string, id: string) {
+      const result = await col(collection).deleteOne({ id })
+      return result.deletedCount > 0
+    },
+
+    async list<T>(collection: string, options?: ListOptions) {
+      let cursor = col(collection).find()
+
+      if (options?.orderBy) {
+        cursor = cursor.sort({ [options.orderBy]: options.order === 'desc' ? -1 : 1 })
+      }
+      if (options?.offset) cursor = cursor.skip(options.offset)
+      if (options?.limit) cursor = cursor.limit(options.limit)
+
+      const docs = await cursor.toArray()
+      return docs.map(stripMongoId) as T[]
+    },
+
+    async query<T>(collection: string, filter: QueryFilter) {
+      const mongoFilter = buildMongoFilter(filter)
+      const docs = await col(collection).find(mongoFilter).toArray()
+      return docs.map(stripMongoId) as T[]
+    },
+
+    async count(collection: string, filter?: QueryFilter) {
+      const mongoFilter = filter ? buildMongoFilter(filter) : {}
+      return col(collection).countDocuments(mongoFilter)
+    },
+  }
+}

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

@@ -0,0 +1,187 @@
+// @geenius/adapters — Neon/Drizzle DB implementation (MVP tier)
+// Wraps a Drizzle ORM instance over Neon Postgres to conform to DbAdapter.
+// Requires: drizzle-orm, @neondatabase/serverless
+//
+// The adapter accepts pre-built Drizzle operator functions via the options
+// to avoid importing drizzle-orm at build time (it's an optional peer dep).
+
+import type { ListOptions, QueryFilter } from '@geenius/adapters-shared'
+import type { DbAdapter } from '@geenius/adapters-shared'
+import { DbError } from '@geenius/adapters-shared'
+
+interface DrizzleTable {
+  [key: string]: unknown
+}
+
+interface DrizzleClient {
+  select: (fields?: Record<string, unknown>) => unknown
+  insert: (table: unknown) => unknown
+  update: (table: unknown) => unknown
+  delete: (table: unknown) => unknown
+}
+
+/** Drizzle operator functions — injected by the consumer */
+export interface DrizzleOperators {
+  eq: (col: unknown, value: unknown) => unknown
+  ne: (col: unknown, value: unknown) => unknown
+  gt: (col: unknown, value: unknown) => unknown
+  gte: (col: unknown, value: unknown) => unknown
+  lt: (col: unknown, value: unknown) => unknown
+  lte: (col: unknown, value: unknown) => unknown
+  inArray: (col: unknown, values: unknown[]) => unknown
+  like: (col: unknown, pattern: string) => unknown
+  and: (...conditions: unknown[]) => unknown
+  asc: (col: unknown) => unknown
+  desc: (col: unknown) => unknown
+  sql: unknown
+  count: (col?: unknown) => unknown
+}
+
+export interface NeonDbAdapterOptions {
+  /** Pre-configured Drizzle client instance */
+  client: DrizzleClient
+  /** Map of collection names to Drizzle table schema objects */
+  tables: Record<string, DrizzleTable>
+  /** Drizzle operator functions (import from 'drizzle-orm') */
+  operators: DrizzleOperators
+}
+
+/**
+ * Creates a Neon-backed DbAdapter using Drizzle ORM.
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/neon-http'
+ * import { neon } from '@neondatabase/serverless'
+ * import { eq, ne, gt, gte, lt, lte, inArray, like, and, asc, desc, sql, count } from 'drizzle-orm'
+ * import * as schema from './schema'
+ *
+ * const db = drizzle(neon(process.env.DATABASE_URL!))
+ *
+ * const adapter = createNeonDbAdapter({
+ *   client: db,
+ *   tables: { tasks: schema.tasks },
+ *   operators: { eq, ne, gt, gte, lt, lte, inArray, like, and, asc, desc, sql, count },
+ * })
+ * ```
+ */
+export function createNeonDbAdapter(options: NeonDbAdapterOptions): DbAdapter {
+  const { client, tables, operators: ops } = options
+
+  function getTable(collection: string) {
+    const table = tables[collection]
+    if (!table) throw new DbError(`No table configured for collection: ${collection}`, 'COLLECTION_NOT_CONFIGURED')
+    return table
+  }
+
+  function buildConditions(table: DrizzleTable, filter: QueryFilter): unknown[] {
+    return filter.map((cond) => {
+      const col = table[cond.field]
+      if (!col) throw new DbError(`Column ${cond.field} not found in table`, 'QUERY_ERROR')
+
+      switch (cond.operator) {
+        case 'eq': return ops.eq(col, cond.value)
+        case 'neq': return ops.ne(col, cond.value)
+        case 'gt': return ops.gt(col, cond.value)
+        case 'gte': return ops.gte(col, cond.value)
+        case 'lt': return ops.lt(col, cond.value)
+        case 'lte': return ops.lte(col, cond.value)
+        case 'in': return ops.inArray(col, cond.value as unknown[])
+        case 'contains': return ops.like(col, `%${cond.value}%`)
+        default: throw new DbError(`Unsupported operator: ${cond.operator}`, 'QUERY_ERROR')
+      }
+    })
+  }
+
+  // Drizzle query builder uses method chaining — typed as `any` at the chain
+  // boundary because Drizzle's internal types are complex generics that can't
+  // be captured without importing the full drizzle-orm type system.
+  /* eslint-disable @typescript-eslint/no-explicit-any */
+  return {
+    async create<T extends Record<string, unknown>>(collection: string, data: Omit<T, 'id'>) {
+      const table = getTable(collection)
+      try {
+        const [result] = await (client.insert(table) as any).values(data).returning()
+        return result as T & { id: string }
+      } catch (err) {
+        throw new DbError(`Insert into "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+    },
+
+    async get<T>(collection: string, id: string) {
+      const table = getTable(collection)
+      try {
+        const [result] = await (client.select() as any).from(table).where(ops.eq(table.id, id)).limit(1)
+        return (result as T | undefined) ?? null
+      } catch (err) {
+        throw new DbError(`Get from "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+    },
+
+    async update<T extends Record<string, unknown>>(collection: string, id: string, data: Partial<T>) {
+      const table = getTable(collection)
+      try {
+        const [result] = await (client.update(table) as any).set(data).where(ops.eq(table.id, id)).returning()
+        return (result as T | undefined) ?? null
+      } catch (err) {
+        throw new DbError(`Update in "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+    },
+
+    async delete(collection: string, id: string) {
+      const table = getTable(collection)
+      try {
+        const result = await (client.delete(table) as any).where(ops.eq(table.id, id)).returning()
+        return Array.isArray(result) && result.length > 0
+      } catch (err) {
+        throw new DbError(`Delete from "${collection}" failed`, 'QUERY_ERROR', err)
+      }
+    },
+
+    async list<T>(collection: string, options?: ListOptions) {
+      const table = getTable(collection)
+      let query = (client.select() as any).from(table)
+
+      if (options?.orderBy) {
+        const col = table[options.orderBy]
+        if (col) {
+          query = query.orderBy(options.order === 'desc' ? ops.desc(col) : ops.asc(col))
+        }
+      }
+      if (options?.limit) query = query.limit(options.limit)
+      if (options?.offset) query = query.offset(options.offset)
+
+      return query as T[]
+    },
+
+    async query<T>(collection: string, filter: QueryFilter) {
+      const table = getTable(collection)
+
+      if (filter.length === 0) {
+        return (client.select() as any).from(table) as T[]
+      }
+
+      const conditions = buildConditions(table, filter)
+
+      return (client.select() as any)
+        .from(table)
+        .where(ops.and(...conditions)) as T[]
+    },
+
+    async count(collection: string, filter?: QueryFilter) {
+      const table = getTable(collection)
+
+      if (!filter || filter.length === 0) {
+        const [result] = await (client.select({ count: ops.count() }) as any).from(table)
+        return Number(result?.count ?? 0)
+      }
+
+      const conditions = buildConditions(table, filter)
+      const [result] = await (client.select({ count: ops.count() }) as any)
+        .from(table)
+        .where(ops.and(...conditions))
+      return Number(result?.count ?? 0)
+    },
+  }
+  /* eslint-enable @typescript-eslint/no-explicit-any */
+}