cl-orm 0.1.0

package/src/queries/where/where.ts

@@ -0,0 +1,50 @@
+import type {
+  Condition,
+  Connector,
+  Param,
+  WhereClause,
+  WhereItem,
+} from '../../types.js';
+
+const isConnector = (value: WhereItem): value is Connector =>
+  typeof value === 'string' && ['AND', 'OR', 'XOR', 'NOT'].includes(value);
+
+const isCondition = (value: WhereItem): value is Condition =>
+  typeof value === 'object' && !Array.isArray(value) && 'condition' in value;
+
+const processItems = (items: WhereItem[]): { sql: string; params: Param[] } => {
+  const parts: string[] = [];
+  const params: Param[] = [];
+
+  for (const item of items) {
+    if (isConnector(item)) {
+      parts.push(item);
+      continue;
+    }
+
+    if (isCondition(item)) {
+      parts.push(item.condition);
+      params.push(...item.params);
+      continue;
+    }
+
+    if (Array.isArray(item)) {
+      const group = processItems(item);
+
+      parts.push(`(${group.sql})`);
+      params.push(...group.params);
+    }
+  }
+
+  return { sql: parts.join(' '), params };
+};
+
+export const buildWhere = (
+  where: WhereClause
+): { sql: string; params: Param[] } => {
+  if (typeof where === 'string') return { sql: where, params: [] };
+  if (isCondition(where))
+    return { sql: where.condition, params: [...where.params] };
+
+  return processItems(where);
+};

package/src/types.ts

@@ -0,0 +1,76 @@
+export type Param = string | number | boolean | null;
+
+export type Condition = {
+  condition: string;
+  params: Param[];
+};
+
+export type Connector = 'AND' | 'OR' | 'XOR' | 'NOT';
+
+export type WhereItem = Condition | Connector | WhereItem[];
+
+export type WhereClause = string | Condition | WhereItem[];
+
+type Values = Record<string, unknown>;
+
+export type InsertOptions = {
+  table: string;
+  values: Values | Values[];
+};
+
+export type JoinOptions = {
+  type: 'left' | 'right' | 'inner' | 'cross';
+  table: string;
+  on: {
+    a: string;
+    b: string;
+  };
+  outer?: boolean;
+};
+
+export type SelectOptions = {
+  distinct?: boolean;
+  columns?: string | string[];
+  table: string;
+  join?: JoinOptions | JoinOptions[];
+  where?: WhereClause;
+  limit?: number;
+  offset?: number;
+  groupBy?: string;
+  orderBy?: [string] | [string, 'ASC' | 'DESC'];
+  params?: unknown[];
+};
+
+export type UpdateOptions = {
+  table: string;
+  set: Record<string, unknown>;
+  where?: WhereClause;
+  params?: unknown[];
+};
+
+export type DeleteOptions = {
+  table: string;
+  where?: WhereClause;
+  limit?: number;
+  params?: unknown[];
+};
+
+export type Meta = D1Meta & Record<string, unknown>;
+
+export type QueryResult<T> = { rows: T[]; meta: Meta };
+
+export type Connection = {
+  query: <T = Record<string, unknown>>(
+    sql: string,
+    values?: unknown[]
+  ) => Promise<QueryResult<T>>;
+  select: {
+    <T = Record<string, unknown>>(
+      options: SelectOptions & { limit: 1 }
+    ): Promise<T | null>;
+    <T = Record<string, unknown>>(options: SelectOptions): Promise<T[]>;
+  };
+  insert: (options: InsertOptions) => Promise<Meta>;
+  update: (options: UpdateOptions) => Promise<Meta>;
+  delete: (options: DeleteOptions) => Promise<Meta>;
+};

package/test/__fixtures__/d1/worker.ts

@@ -0,0 +1,70 @@
+import { OP, useD1 } from '../../../src/index.js';
+
+interface Env {
+  DB: D1Database;
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url);
+    const db = useD1(env.DB);
+
+    switch (url.pathname) {
+      case '/setup': {
+        await db.query('DROP TABLE IF EXISTS users');
+        await db.query(
+          'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)'
+        );
+        return Response.json({ ok: true });
+      }
+
+      case '/query': {
+        const sql = url.searchParams.get('sql')!;
+        const result = await db.query(sql);
+        return Response.json(result);
+      }
+
+      case '/insert': {
+        const name = url.searchParams.get('name')!;
+        const email = url.searchParams.get('email')!;
+        const meta = await db.insert({
+          table: 'users',
+          values: { name, email },
+        });
+        return Response.json(meta);
+      }
+
+      case '/select': {
+        const limit = url.searchParams.get('limit');
+        const rows = await db.select({
+          table: 'users',
+          ...(limit ? { limit: Number(limit) } : {}),
+        });
+        return Response.json({ rows });
+      }
+
+      case '/update': {
+        const name = url.searchParams.get('name')!;
+        const where = url.searchParams.get('where')!;
+        const meta = await db.update({
+          table: 'users',
+          set: { name },
+          where: OP.eq('name', where),
+        });
+        return Response.json(meta);
+      }
+
+      case '/delete': {
+        const name = url.searchParams.get('name')!;
+        const meta = await db.delete({
+          table: 'users',
+          where: OP.eq('name', name),
+        });
+        return Response.json(meta);
+      }
+
+      default:
+        return new Response('Not found', { status: 404 });
+    }
+  },
+};

package/test/__fixtures__/d1/wrangler.jsonc

@@ -0,0 +1,13 @@
+{
+  "$schema": "../../../node_modules/wrangler/config-schema.json",
+  "name": "d1-test",
+  "main": "worker.ts",
+  "compatibility_date": "2026-01-28",
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "d1-tutorial-db",
+      "database_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+    }
+  ]
+}

package/test/__fixtures__/do/worker.ts

@@ -0,0 +1,106 @@
+import type { Connection } from '../../../src/types.js';
+import { DurableObject } from 'cloudflare:workers';
+import { OP, useDO } from '../../../src/index.js';
+
+interface Env {
+  MY_DO: DurableObjectNamespace<MyDurableObject>;
+}
+
+export class MyDurableObject extends DurableObject<Env> {
+  private db: Connection;
+
+  constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env);
+    this.db = useDO(ctx.storage.sql);
+  }
+
+  async setup() {
+    await this.db.query('DROP TABLE IF EXISTS users');
+    await this.db.query(
+      'CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)'
+    );
+    return { ok: true };
+  }
+
+  async queryRaw(sql: string) {
+    return this.db.query(sql);
+  }
+
+  async insertUser(name: string, email: string) {
+    return this.db.insert({
+      table: 'users',
+      values: { name, email },
+    });
+  }
+
+  async selectUsers(limit?: number) {
+    return this.db.select({
+      table: 'users',
+      ...(limit ? { limit: limit as 1 } : {}),
+    });
+  }
+
+  async updateUser(oldName: string, newName: string) {
+    return this.db.update({
+      table: 'users',
+      set: { name: newName },
+      where: OP.eq('name', oldName),
+    });
+  }
+
+  async deleteUser(name: string) {
+    return this.db.delete({
+      table: 'users',
+      where: OP.eq('name', name),
+    });
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const url = new URL(request.url);
+    const DO = env.MY_DO.get(env.MY_DO.idFromName('default'));
+
+    switch (url.pathname) {
+      case '/setup': {
+        const result = await DO.setup();
+        return Response.json(result);
+      }
+
+      case '/query': {
+        const sql = url.searchParams.get('sql')!;
+        const result = await DO.queryRaw(sql);
+        return Response.json(result);
+      }
+
+      case '/insert': {
+        const name = url.searchParams.get('name')!;
+        const email = url.searchParams.get('email')!;
+        const meta = await DO.insertUser(name, email);
+        return Response.json(meta);
+      }
+
+      case '/select': {
+        const limit = url.searchParams.get('limit');
+        const rows = await DO.selectUsers(limit ? Number(limit) : undefined);
+        return Response.json({ rows });
+      }
+
+      case '/update': {
+        const oldName = url.searchParams.get('oldName')!;
+        const newName = url.searchParams.get('newName')!;
+        const meta = await DO.updateUser(oldName, newName);
+        return Response.json(meta);
+      }
+
+      case '/delete': {
+        const name = url.searchParams.get('name')!;
+        const meta = await DO.deleteUser(name);
+        return Response.json(meta);
+      }
+
+      default:
+        return new Response('Not found', { status: 404 });
+    }
+  },
+};

package/test/__fixtures__/do/wrangler.jsonc

@@ -0,0 +1,20 @@
+{
+  "$schema": "../../../node_modules/wrangler/config-schema.json",
+  "name": "do-test",
+  "main": "worker.ts",
+  "compatibility_date": "2026-01-28",
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "MY_DO",
+        "class_name": "MyDurableObject"
+      }
+    ]
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_sqlite_classes": ["MyDurableObject"]
+    }
+  ]
+}

package/test/e2e/d1.test.ts

@@ -0,0 +1,113 @@
+import { assert, beforeEach, describe, it, kill, startScript } from 'poku';
+
+const PORT = 8787;
+const BASE_URL = `http://localhost:${PORT}`;
+
+describe(async () => {
+  await kill.port(PORT);
+
+  const server = await startScript('dev:d1', {
+    startAfter: 'Ready on',
+    timeout: 5000,
+    verbose: true,
+  });
+
+  try {
+    await describe('useD1', async () => {
+      beforeEach(async () => {
+        const res = await fetch(`${BASE_URL}/setup`);
+        assert.strictEqual(res.status, 200);
+      });
+
+      await it('should insert a row', async () => {
+        const res = await fetch(
+          `${BASE_URL}/insert?name=Alice&email=alice@example.com`
+        );
+
+        assert.strictEqual(res.status, 200);
+
+        const meta = await res.json();
+
+        assert.ok(meta);
+      });
+
+      await it('should select multiple rows', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(`${BASE_URL}/select`);
+
+        assert.strictEqual(res.status, 200);
+
+        const data = (await res.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.ok(Array.isArray(data.rows));
+        assert.ok(data.rows.length > 0);
+        assert.strictEqual(data.rows[0].name, 'Alice');
+      });
+
+      await it('should select a single row with limit 1', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(`${BASE_URL}/select?limit=1`);
+
+        assert.strictEqual(res.status, 200);
+
+        const data = (await res.json()) as {
+          rows: { id: number; name: string; email: string };
+        };
+
+        assert.ok(data.rows !== null);
+        assert.strictEqual(data.rows.name, 'Alice');
+      });
+
+      await it('should run a raw query', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(
+          `${BASE_URL}/query?sql=${encodeURIComponent('SELECT * FROM users')}`
+        );
+
+        assert.strictEqual(res.status, 200);
+
+        const data = (await res.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.ok(data.rows.length > 0);
+        assert.strictEqual(data.rows[0].name, 'Alice');
+      });
+
+      await it('should update a row', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+        const res = await fetch(`${BASE_URL}/update?name=Bob&where=Alice`);
+
+        assert.strictEqual(res.status, 200);
+
+        const selectRes = await fetch(`${BASE_URL}/select`);
+        const data = (await selectRes.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.strictEqual(data.rows[0].name, 'Bob');
+      });
+
+      await it('should delete a row', async () => {
+        await fetch(`${BASE_URL}/insert?name=Bob&email=bob@example.com`);
+        const res = await fetch(`${BASE_URL}/delete?name=Bob`);
+
+        assert.strictEqual(res.status, 200);
+
+        const selectRes = await fetch(`${BASE_URL}/select`);
+        const data = (await selectRes.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.strictEqual(data.rows.length, 0);
+      });
+    });
+  } finally {
+    await server.end(PORT);
+  }
+});

package/test/e2e/do.test.ts

@@ -0,0 +1,116 @@
+import { assert, beforeEach, describe, it, kill, startScript } from 'poku';
+
+const PORT = 8788;
+const BASE_URL = `http://localhost:${PORT}`;
+
+describe(async () => {
+  await kill.port(PORT);
+
+  const server = await startScript('dev:do', {
+    startAfter: 'Ready on',
+    timeout: 5000,
+    verbose: true,
+  });
+
+  try {
+    await describe('useDO', async () => {
+      beforeEach(async () => {
+        const res = await fetch(`${BASE_URL}/setup`);
+
+        assert.strictEqual(res.status, 200);
+      });
+
+      await it('should insert a row', async () => {
+        const res = await fetch(
+          `${BASE_URL}/insert?name=Alice&email=alice@example.com`
+        );
+
+        assert.strictEqual(res.status, 200);
+
+        const meta = await res.json();
+
+        assert.ok(meta);
+      });
+
+      await it('should select multiple rows', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(`${BASE_URL}/select`);
+
+        assert.strictEqual(res.status, 200);
+
+        const data = (await res.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.ok(Array.isArray(data.rows));
+        assert.ok(data.rows.length > 0);
+        assert.strictEqual(data.rows[0].name, 'Alice');
+      });
+
+      await it('should select a single row with limit 1', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(`${BASE_URL}/select?limit=1`);
+
+        assert.strictEqual(res.status, 200);
+
+        const data = (await res.json()) as {
+          rows: { id: number; name: string; email: string };
+        };
+
+        assert.ok(data.rows !== null);
+        assert.strictEqual(data.rows.name, 'Alice');
+      });
+
+      await it('should run a raw query', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(
+          `${BASE_URL}/query?sql=${encodeURIComponent('SELECT * FROM users')}`
+        );
+
+        assert.strictEqual(res.status, 200);
+
+        const data = (await res.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.ok(data.rows.length > 0);
+        assert.strictEqual(data.rows[0].name, 'Alice');
+      });
+
+      await it('should update a user', async () => {
+        await fetch(`${BASE_URL}/insert?name=Alice&email=alice@example.com`);
+
+        const res = await fetch(`${BASE_URL}/update?oldName=Alice&newName=Bob`);
+
+        assert.strictEqual(res.status, 200);
+
+        const selectRes = await fetch(`${BASE_URL}/select`);
+        const data = (await selectRes.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.strictEqual(data.rows[0].name, 'Bob');
+      });
+
+      await it('should delete a user', async () => {
+        await fetch(`${BASE_URL}/insert?name=Bob&email=bob@example.com`);
+
+        const res = await fetch(`${BASE_URL}/delete?name=Bob`);
+
+        assert.strictEqual(res.status, 200);
+
+        const selectRes = await fetch(`${BASE_URL}/select`);
+        const data = (await selectRes.json()) as {
+          rows: Array<{ id: number; name: string; email: string }>;
+        };
+
+        assert.strictEqual(data.rows.length, 0);
+      });
+    });
+  } finally {
+    await server.end(PORT);
+  }
+});

package/test/unit/buildDelete.test.ts

@@ -0,0 +1,36 @@
+import { assert, describe, it } from 'poku';
+import { buildDelete } from '../../src/queries/delete.js';
+import { OP } from '../../src/queries/where/operators.js';
+
+describe('buildDelete', () => {
+  it('should build a basic delete', () => {
+    const result = buildDelete({ table: 'users' });
+    assert.strictEqual(result.sql, 'DELETE FROM `users`');
+    assert.deepStrictEqual(result.params, []);
+  });
+
+  it('should build delete with where clause', () => {
+    const result = buildDelete({
+      table: 'users',
+      where: OP.eq('name', 'Alice'),
+    });
+    assert.strictEqual(result.sql, 'DELETE FROM `users` WHERE `name` = ?');
+    assert.deepStrictEqual(result.params, ['Alice']);
+  });
+
+  it('should build delete with limit', () => {
+    const result = buildDelete({ table: 'users', limit: 1 });
+    assert.strictEqual(result.sql, 'DELETE FROM `users` LIMIT ?');
+    assert.deepStrictEqual(result.params, [1]);
+  });
+
+  it('should build delete with extra params', () => {
+    const result = buildDelete({
+      table: 'users',
+      where: OP.eq('id', 1),
+      params: ['extra'],
+    });
+    assert.strictEqual(result.sql, 'DELETE FROM `users` WHERE `id` = ?');
+    assert.deepStrictEqual(result.params, ['extra', 1]);
+  });
+});

package/test/unit/buildInsert.test.ts

@@ -0,0 +1,36 @@
+import { assert, describe, it } from 'poku';
+import { buildInsert } from '../../src/queries/insert.js';
+
+describe('buildInsert', () => {
+  it('should build a single row insert', () => {
+    const result = buildInsert({
+      table: 'users',
+      values: { name: 'Alice', email: 'a@b.com' },
+    });
+    assert.strictEqual(
+      result.sql,
+      'INSERT INTO `users` (`name`, `email`) VALUES (?, ?)'
+    );
+    assert.deepStrictEqual(result.params, ['Alice', 'a@b.com']);
+  });
+
+  it('should build a multi-row insert', () => {
+    const result = buildInsert({
+      table: 'users',
+      values: [
+        { name: 'Alice', email: 'a@b.com' },
+        { name: 'Bob', email: 'b@b.com' },
+      ],
+    });
+    assert.strictEqual(
+      result.sql,
+      'INSERT INTO `users` (`name`, `email`) VALUES (?, ?), (?, ?)'
+    );
+    assert.deepStrictEqual(result.params, [
+      'Alice',
+      'a@b.com',
+      'Bob',
+      'b@b.com',
+    ]);
+  });
+});