cl-orm 0.1.0 → 0.1.1

package/test/__fixtures__/do/worker.ts

@@ -1,106 +0,0 @@
-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

@@ -1,20 +0,0 @@
-{
-  "$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

@@ -1,113 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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',
-    ]);
-  });
-});

package/test/unit/buildSelect.test.ts

@@ -1,137 +0,0 @@
-import { assert, describe, it } from 'poku';
-import { buildSelect } from '../../src/queries/select.js';
-import { OP } from '../../src/queries/where/operators.js';
-
-describe('buildSelect', () => {
-  it('should build a basic select', () => {
-    const result = buildSelect({ table: 'users' });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users`');
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with specific columns', () => {
-    const result = buildSelect({ table: 'users', columns: ['name', 'email'] });
-    assert.strictEqual(result.sql, 'SELECT `name`, `email` FROM `users`');
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with string column', () => {
-    const result = buildSelect({ table: 'users', columns: 'COUNT(*)' });
-    assert.strictEqual(result.sql, 'SELECT COUNT(*) FROM `users`');
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with distinct', () => {
-    const result = buildSelect({ table: 'users', distinct: true });
-    assert.strictEqual(result.sql, 'SELECT DISTINCT * FROM `users`');
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with where clause', () => {
-    const result = buildSelect({
-      table: 'users',
-      where: OP.eq('name', 'Alice'),
-    });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users` WHERE `name` = ?');
-    assert.deepStrictEqual(result.params, ['Alice']);
-  });
-
-  it('should build select with limit', () => {
-    const result = buildSelect({ table: 'users', limit: 10 });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users` LIMIT ?');
-    assert.deepStrictEqual(result.params, [10]);
-  });
-
-  it('should build select with offset', () => {
-    const result = buildSelect({ table: 'users', limit: 10, offset: 5 });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users` LIMIT ? OFFSET ?');
-    assert.deepStrictEqual(result.params, [10, 5]);
-  });
-
-  it('should build select with orderBy', () => {
-    const result = buildSelect({ table: 'users', orderBy: ['name', 'DESC'] });
-    assert.strictEqual(
-      result.sql,
-      'SELECT * FROM `users` ORDER BY `name` DESC'
-    );
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with orderBy default ASC', () => {
-    const result = buildSelect({ table: 'users', orderBy: ['name'] });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users` ORDER BY `name` ASC');
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with groupBy', () => {
-    const result = buildSelect({ table: 'users', groupBy: 'name' });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users` GROUP BY `name`');
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with join', () => {
-    const result = buildSelect({
-      table: 'users',
-      join: {
-        type: 'inner',
-        table: 'orders',
-        on: { a: 'users.id', b: 'orders.user_id' },
-      },
-    });
-    assert.strictEqual(
-      result.sql,
-      'SELECT * FROM `users` INNER JOIN `orders` ON `users`.`id` = `orders`.`user_id`'
-    );
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with outer join', () => {
-    const result = buildSelect({
-      table: 'users',
-      join: {
-        type: 'left',
-        table: 'orders',
-        on: { a: 'users.id', b: 'orders.user_id' },
-        outer: true,
-      },
-    });
-    assert.strictEqual(
-      result.sql,
-      'SELECT * FROM `users` LEFT OUTER JOIN `orders` ON `users`.`id` = `orders`.`user_id`'
-    );
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with multiple joins', () => {
-    const result = buildSelect({
-      table: 'users',
-      join: [
-        {
-          type: 'inner',
-          table: 'orders',
-          on: { a: 'users.id', b: 'orders.user_id' },
-        },
-        {
-          type: 'left',
-          table: 'items',
-          on: { a: 'orders.id', b: 'items.order_id' },
-        },
-      ],
-    });
-    assert.strictEqual(
-      result.sql,
-      'SELECT * FROM `users` INNER JOIN `orders` ON `users`.`id` = `orders`.`user_id` LEFT JOIN `items` ON `orders`.`id` = `items`.`order_id`'
-    );
-    assert.deepStrictEqual(result.params, []);
-  });
-
-  it('should build select with params', () => {
-    const result = buildSelect({
-      table: 'users',
-      where: 'name = ?',
-      params: ['Alice'],
-    });
-    assert.strictEqual(result.sql, 'SELECT * FROM `users` WHERE name = ?');
-    assert.deepStrictEqual(result.params, ['Alice']);
-  });
-});

package/test/unit/buildUpdate.test.ts

@@ -1,34 +0,0 @@
-import { assert, describe, it } from 'poku';
-import { buildUpdate } from '../../src/queries/update.js';
-import { OP } from '../../src/queries/where/operators.js';
-
-describe('buildUpdate', () => {
-  it('should build a basic update', () => {
-    const result = buildUpdate({ table: 'users', set: { name: 'Bob' } });
-    assert.strictEqual(result.sql, 'UPDATE `users` SET `name` = ?');
-    assert.deepStrictEqual(result.params, ['Bob']);
-  });
-
-  it('should build update with where clause', () => {
-    const result = buildUpdate({
-      table: 'users',
-      set: { name: 'Bob' },
-      where: OP.eq('name', 'Alice'),
-    });
-    assert.strictEqual(
-      result.sql,
-      'UPDATE `users` SET `name` = ? WHERE `name` = ?'
-    );
-    assert.deepStrictEqual(result.params, ['Bob', 'Alice']);
-  });
-
-  it('should build update with extra params', () => {
-    const result = buildUpdate({
-      table: 'users',
-      set: { name: 'Bob' },
-      params: ['extra'],
-    });
-    assert.strictEqual(result.sql, 'UPDATE `users` SET `name` = ?');
-    assert.deepStrictEqual(result.params, ['Bob', 'extra']);
-  });
-});