@pineliner/odb-client 1.0.6 → 1.0.7

package/src/index.ts

@@ -18,8 +18,37 @@ export {
   BunSQLiteAdapter,
   LibSQLAdapter,
   ODBLiteAdapter,
+  // SQL Template helpers (postgres.js-compatible)
+  sql as sqlTemplate,
+  raw as rawSQL,
+  empty,
+  fragment as sqlFragment,
+  join as sqlJoin,
+  set,
+  where as sqlWhere,
+  convertTemplateToQuery,
 } from './database/index.ts';
 
+// ORM exports (Drizzle-like query builder)
+export {
+  ORM,
+  createORM,
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  like,
+  inArray,
+  isNull,
+  isNotNull,
+  and,
+  or,
+  type WhereCondition,
+  type OrderByDirection,
+} from './orm/index.ts';
+
 // Export all types
 export type {
   ODBLiteConfig,
@@ -56,6 +85,8 @@ export type {
   TenantInfo,
   ParsedStatements,
   SQLParserOptions,
+  SqlQuery,
+  SqlFragment,
 } from './database/index.ts';
 
 // Export error classes

package/src/orm/index.ts

@@ -0,0 +1,538 @@
+/**
+ * Simple ORM for Database Operations
+ *
+ * Provides a Drizzle-like API for common database operations
+ * Wraps the raw SQL query interface with a more intuitive syntax
+ */
+
+import type { Connection } from '../database/index.ts'
+
+// ============================================================
+// TYPES
+// ============================================================
+
+type WhereCondition = {
+  sql: string
+  params: any[]
+}
+
+type OrderByDirection = 'ASC' | 'DESC'
+
+// ============================================================
+// WHERE CLAUSE BUILDERS
+// ============================================================
+
+/**
+ * Equal condition
+ */
+export function eq(field: string, value: any): WhereCondition {
+  return {
+    sql: `${field} = ?`,
+    params: [value]
+  }
+}
+
+/**
+ * Not equal condition
+ */
+export function ne(field: string, value: any): WhereCondition {
+  return {
+    sql: `${field} != ?`,
+    params: [value]
+  }
+}
+
+/**
+ * Greater than condition
+ */
+export function gt(field: string, value: any): WhereCondition {
+  return {
+    sql: `${field} > ?`,
+    params: [value]
+  }
+}
+
+/**
+ * Greater than or equal condition
+ */
+export function gte(field: string, value: any): WhereCondition {
+  return {
+    sql: `${field} >= ?`,
+    params: [value]
+  }
+}
+
+/**
+ * Less than condition
+ */
+export function lt(field: string, value: any): WhereCondition {
+  return {
+    sql: `${field} < ?`,
+    params: [value]
+  }
+}
+
+/**
+ * Less than or equal condition
+ */
+export function lte(field: string, value: any): WhereCondition {
+  return {
+    sql: `${field} <= ?`,
+    params: [value]
+  }
+}
+
+/**
+ * LIKE condition
+ */
+export function like(field: string, pattern: string): WhereCondition {
+  return {
+    sql: `${field} LIKE ?`,
+    params: [pattern]
+  }
+}
+
+/**
+ * IN condition
+ */
+export function inArray(field: string, values: any[]): WhereCondition {
+  const placeholders = values.map(() => '?').join(', ')
+  return {
+    sql: `${field} IN (${placeholders})`,
+    params: values
+  }
+}
+
+/**
+ * IS NULL condition
+ */
+export function isNull(field: string): WhereCondition {
+  return {
+    sql: `${field} IS NULL`,
+    params: []
+  }
+}
+
+/**
+ * IS NOT NULL condition
+ */
+export function isNotNull(field: string): WhereCondition {
+  return {
+    sql: `${field} IS NOT NULL`,
+    params: []
+  }
+}
+
+/**
+ * AND combinator
+ */
+export function and(...conditions: WhereCondition[]): WhereCondition {
+  const sql = conditions.map(c => `(${c.sql})`).join(' AND ')
+  const params = conditions.flatMap(c => c.params)
+  return { sql, params }
+}
+
+/**
+ * OR combinator
+ */
+export function or(...conditions: WhereCondition[]): WhereCondition {
+  const sql = conditions.map(c => `(${c.sql})`).join(' OR ')
+  const params = conditions.flatMap(c => c.params)
+  return { sql, params }
+}
+
+// ============================================================
+// QUERY BUILDERS
+// ============================================================
+
+/**
+ * Select Query Builder
+ */
+class SelectBuilder<T = any> {
+  private db: Connection
+  private tableName: string
+  private selectFields: string[] = ['*']
+  private whereConditions: WhereCondition[] = []
+  private orderByField?: string
+  private orderByDir: OrderByDirection = 'ASC'
+  private limitValue?: number
+  private offsetValue?: number
+
+  constructor(db: Connection, tableName: string) {
+    this.db = db
+    this.tableName = tableName
+  }
+
+  /**
+   * Specify which fields to select
+   */
+  select(fields: Record<string, any> = {}): this {
+    if (Object.keys(fields).length === 0) {
+      this.selectFields = ['*']
+    } else {
+      this.selectFields = Object.keys(fields)
+    }
+    return this
+  }
+
+  /**
+   * Add WHERE clause (can be called multiple times, will be combined with AND)
+   */
+  where(condition: WhereCondition): this {
+    this.whereConditions.push(condition)
+    return this
+  }
+
+  /**
+   * Add ORDER BY clause
+   */
+  orderBy(field: string, direction: OrderByDirection = 'ASC'): this {
+    this.orderByField = field
+    this.orderByDir = direction
+    return this
+  }
+
+  /**
+   * Add LIMIT clause
+   */
+  limit(value: number): this {
+    this.limitValue = value
+    return this
+  }
+
+  /**
+   * Add OFFSET clause
+   */
+  offset(value: number): this {
+    this.offsetValue = value
+    return this
+  }
+
+  /**
+   * Execute the query
+   */
+  async execute(): Promise<T[]> {
+    const fields = this.selectFields.join(', ')
+    const params: any[] = []
+    let sql = `SELECT ${fields} FROM ${this.tableName}`
+
+    // Combine all where conditions with AND
+    if (this.whereConditions.length > 0) {
+      const combinedCondition = this.whereConditions.length === 1
+        ? this.whereConditions[0]!
+        : and(...this.whereConditions)
+      sql += ` WHERE ${combinedCondition.sql}`
+      params.push(...combinedCondition.params)
+    }
+
+    if (this.orderByField) {
+      sql += ` ORDER BY ${this.orderByField} ${this.orderByDir}`
+    }
+
+    if (this.limitValue !== undefined) {
+      sql += ` LIMIT ?`
+      params.push(this.limitValue)
+    }
+
+    if (this.offsetValue !== undefined) {
+      sql += ` OFFSET ?`
+      params.push(this.offsetValue)
+    }
+
+    const result = await this.db.execute(sql, params)
+    return result.rows as T[]
+  }
+}
+
+/**
+ * Insert Query Builder
+ */
+class InsertBuilder<T = any> {
+  private db: Connection
+  private tableName: string
+  private insertValues: Record<string, any> = {}
+  private shouldReturn = false
+
+  constructor(db: Connection, tableName: string) {
+    this.db = db
+    this.tableName = tableName
+  }
+
+  /**
+   * Specify values to insert
+   */
+  values(data: Record<string, any>): this {
+    this.insertValues = data
+    return this
+  }
+
+  /**
+   * Return inserted row
+   */
+  returning(): this {
+    this.shouldReturn = true
+    return this
+  }
+
+  /**
+   * Execute the query
+   */
+  async execute(): Promise<T[]> {
+    const fields = Object.keys(this.insertValues)
+    const placeholders = fields.map(() => '?').join(', ')
+    const values = fields.map(f => this.insertValues[f])
+
+    let sql = `
+      INSERT INTO ${this.tableName} (${fields.join(', ')})
+      VALUES (${placeholders})
+    `
+
+    await this.db.execute(sql, values)
+
+    if (this.shouldReturn) {
+      // Get the last inserted row
+      const selectSql = `SELECT * FROM ${this.tableName} ORDER BY id DESC LIMIT 1`
+      const result = await this.db.execute(selectSql, [])
+      return result.rows as T[]
+    }
+
+    return []
+  }
+}
+
+/**
+ * Update Query Builder
+ */
+class UpdateBuilder<T = any> {
+  private db: Connection
+  private tableName: string
+  private updateValues: Record<string, any> = {}
+  private whereConditions: WhereCondition[] = []
+  private shouldReturn = false
+
+  constructor(db: Connection, tableName: string) {
+    this.db = db
+    this.tableName = tableName
+  }
+
+  /**
+   * Specify values to update
+   */
+  set(data: Record<string, any>): this {
+    this.updateValues = data
+    return this
+  }
+
+  /**
+   * Add WHERE clause (can be called multiple times, will be combined with AND)
+   */
+  where(condition: WhereCondition): this {
+    this.whereConditions.push(condition)
+    return this
+  }
+
+  /**
+   * Return updated row
+   */
+  returning(): this {
+    this.shouldReturn = true
+    return this
+  }
+
+  /**
+   * Execute the query
+   */
+  async execute(): Promise<T[]> {
+    const fields = Object.keys(this.updateValues)
+    const setClause = fields.map(f => `${f} = ?`).join(', ')
+    const values = fields.map(f => this.updateValues[f])
+
+    let sql = `UPDATE ${this.tableName} SET ${setClause}`
+    const params = [...values]
+
+    // Combine all where conditions with AND
+    if (this.whereConditions.length > 0) {
+      const combinedCondition = this.whereConditions.length === 1
+        ? this.whereConditions[0]!
+        : and(...this.whereConditions)
+      sql += ` WHERE ${combinedCondition.sql}`
+      params.push(...combinedCondition.params)
+    }
+
+    await this.db.execute(sql, params)
+
+    if (this.shouldReturn && this.whereConditions.length > 0) {
+      // Get the updated rows
+      const combinedCondition = this.whereConditions.length === 1
+        ? this.whereConditions[0]!
+        : and(...this.whereConditions)
+      const selectSql = `SELECT * FROM ${this.tableName} WHERE ${combinedCondition.sql}`
+      const result = await this.db.execute(selectSql, combinedCondition.params)
+      return result.rows as T[]
+    }
+
+    return []
+  }
+}
+
+/**
+ * Delete Query Builder
+ */
+class DeleteBuilder {
+  private db: Connection
+  private tableName: string
+  private whereConditions: WhereCondition[] = []
+
+  constructor(db: Connection, tableName: string) {
+    this.db = db
+    this.tableName = tableName
+  }
+
+  /**
+   * Add WHERE clause (can be called multiple times, will be combined with AND)
+   */
+  where(condition: WhereCondition): this {
+    this.whereConditions.push(condition)
+    return this
+  }
+
+  /**
+   * Execute the query
+   */
+  async execute(): Promise<void> {
+    let sql = `DELETE FROM ${this.tableName}`
+    const params: any[] = []
+
+    // Combine all where conditions with AND
+    if (this.whereConditions.length > 0) {
+      const combinedCondition = this.whereConditions.length === 1
+        ? this.whereConditions[0]!
+        : and(...this.whereConditions)
+      sql += ` WHERE ${combinedCondition.sql}`
+      params.push(...combinedCondition.params)
+    }
+
+    await this.db.execute(sql, params)
+  }
+}
+
+/**
+ * Table Query Builder
+ */
+class TableQueryBuilder {
+  private db: Connection
+  private tableName: string
+
+  constructor(db: Connection, tableName: string) {
+    this.db = db
+    this.tableName = tableName
+  }
+
+  /**
+   * Start a SELECT query
+   */
+  select(fields?: Record<string, any>): SelectBuilder {
+    const builder = new SelectBuilder(this.db, this.tableName)
+    if (fields) {
+      builder.select(fields)
+    }
+    return builder
+  }
+
+  /**
+   * Start an INSERT query
+   */
+  insert(): InsertBuilder {
+    return new InsertBuilder(this.db, this.tableName)
+  }
+
+  /**
+   * Start an UPDATE query
+   */
+  update(): UpdateBuilder {
+    return new UpdateBuilder(this.db, this.tableName)
+  }
+
+  /**
+   * Start a DELETE query
+   */
+  delete(): DeleteBuilder {
+    return new DeleteBuilder(this.db, this.tableName)
+  }
+}
+
+// ============================================================
+// ORM CONNECTION WRAPPER
+// ============================================================
+
+/**
+ * ORM Wrapper for Connection
+ * Provides Drizzle-like syntax for database operations
+ */
+export class ORM {
+  private db: Connection
+
+  constructor(db: Connection) {
+    this.db = db
+  }
+
+  /**
+   * Access a table for querying
+   */
+  table(tableName: string): TableQueryBuilder {
+    return new TableQueryBuilder(this.db, tableName)
+  }
+
+  /**
+   * Select from table (shorthand)
+   */
+  select(fields?: Record<string, any>) {
+    return {
+      from: (tableName: string) => {
+        const builder = new SelectBuilder(this.db, tableName)
+        if (fields) {
+          builder.select(fields)
+        }
+        return builder
+      }
+    }
+  }
+
+  /**
+   * Insert into table (shorthand)
+   */
+  insert(tableName: string) {
+    return new InsertBuilder(this.db, tableName)
+  }
+
+  /**
+   * Update table (shorthand)
+   */
+  update(tableName: string) {
+    return new UpdateBuilder(this.db, tableName)
+  }
+
+  /**
+   * Delete from table (shorthand)
+   */
+  delete(tableName: string) {
+    return new DeleteBuilder(this.db, tableName)
+  }
+
+  /**
+   * Raw query access
+   */
+  execute(sql: string, params?: any[]) {
+    return this.db.execute(sql, params)
+  }
+}
+
+/**
+ * Create ORM instance from Connection
+ */
+export function createORM(db: Connection): ORM {
+  return new ORM(db)
+}
+
+// Export types
+export type { WhereCondition, OrderByDirection }

package/src/types.ts

@@ -10,6 +10,7 @@ export interface ODBLiteConfig {
 export interface QueryResult<T = any> {
   rows: T[];
   rowsAffected: number;
+  lastInsertRowid?: number | bigint;
   executionTime: number;
   databaseName?: string;
 }
@@ -19,6 +20,7 @@ export interface ODBLiteResponse<T = any> {
   data?: T[];
   rows?: T[];
   rowsAffected?: number;
+  lastInsertRowid?: number | bigint;
   executionTime?: number;
   dbId?: string;
   databaseName?: string;