cl-orm 0.1.0

package/test/unit/buildSelect.test.ts

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

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

package/test/unit/buildWhere.test.ts

@@ -0,0 +1,249 @@
+import { assert, describe, it } from 'poku';
+import { OP } from '../../src/queries/where/operators.js';
+import { buildWhere } from '../../src/queries/where/where.js';
+
+describe('buildWhere', () => {
+  it('should handle raw string', () => {
+    const result = buildWhere('id = 1');
+    assert.strictEqual(result.sql, 'id = 1');
+    assert.deepStrictEqual(result.params, []);
+  });
+
+  it('should handle a single eq condition', () => {
+    const result = buildWhere(OP.eq('name', 'Alice'));
+    assert.strictEqual(result.sql, '`name` = ?');
+    assert.deepStrictEqual(result.params, ['Alice']);
+  });
+
+  it('should handle a single ne condition', () => {
+    const result = buildWhere(OP.ne('status', 'inactive'));
+    assert.strictEqual(result.sql, '`status` != ?');
+    assert.deepStrictEqual(result.params, ['inactive']);
+  });
+
+  it('should handle a single gt condition', () => {
+    const result = buildWhere(OP.gt('age', 18));
+    assert.strictEqual(result.sql, '`age` > ?');
+    assert.deepStrictEqual(result.params, [18]);
+  });
+
+  it('should handle a single lt condition', () => {
+    const result = buildWhere(OP.lt('price', 100));
+    assert.strictEqual(result.sql, '`price` < ?');
+    assert.deepStrictEqual(result.params, [100]);
+  });
+
+  it('should handle a single gte condition', () => {
+    const result = buildWhere(OP.gte('score', 90));
+    assert.strictEqual(result.sql, '`score` >= ?');
+    assert.deepStrictEqual(result.params, [90]);
+  });
+
+  it('should handle a single lte condition', () => {
+    const result = buildWhere(OP.lte('quantity', 0));
+    assert.strictEqual(result.sql, '`quantity` <= ?');
+    assert.deepStrictEqual(result.params, [0]);
+  });
+
+  it('should handle a single like condition', () => {
+    const result = buildWhere(OP.like('name', '%Ali%'));
+    assert.strictEqual(result.sql, '`name` LIKE ?');
+    assert.deepStrictEqual(result.params, ['%Ali%']);
+  });
+
+  it('should handle a single notLike condition', () => {
+    const result = buildWhere(OP.notLike('name', '%Bot%'));
+    assert.strictEqual(result.sql, '`name` NOT LIKE ?');
+    assert.deepStrictEqual(result.params, ['%Bot%']);
+  });
+
+  it('should handle a single isNull condition', () => {
+    const result = buildWhere(OP.isNull('email'));
+    assert.strictEqual(result.sql, '`email` IS NULL');
+    assert.deepStrictEqual(result.params, []);
+  });
+
+  it('should handle a single isNotNull condition', () => {
+    const result = buildWhere(OP.isNotNull('email'));
+    assert.strictEqual(result.sql, '`email` IS NOT NULL');
+    assert.deepStrictEqual(result.params, []);
+  });
+
+  it('should handle a single in condition with values', () => {
+    const result = buildWhere(OP.in('id', [1, 2, 3]));
+    assert.strictEqual(result.sql, '`id` IN (?, ?, ?)');
+    assert.deepStrictEqual(result.params, [1, 2, 3]);
+  });
+
+  it('should handle a single in condition with subquery', () => {
+    const result = buildWhere(
+      OP.in('id', 'SELECT id FROM other WHERE x = ?', [42])
+    );
+    assert.strictEqual(
+      result.sql,
+      '`id` IN (SELECT id FROM other WHERE x = ?)'
+    );
+    assert.deepStrictEqual(result.params, [42]);
+  });
+
+  it('should handle a single notIn condition with values', () => {
+    const result = buildWhere(OP.notIn('id', [4, 5]));
+    assert.strictEqual(result.sql, '`id` NOT IN (?, ?)');
+    assert.deepStrictEqual(result.params, [4, 5]);
+  });
+
+  it('should handle a single notIn condition with subquery', () => {
+    const result = buildWhere(OP.notIn('id', 'SELECT id FROM blocked', []));
+    assert.strictEqual(result.sql, '`id` NOT IN (SELECT id FROM blocked)');
+    assert.deepStrictEqual(result.params, []);
+  });
+
+  it('should handle a single between condition', () => {
+    const result = buildWhere(OP.between('age', [18, 65]));
+    assert.strictEqual(result.sql, '`age` BETWEEN ? AND ?');
+    assert.deepStrictEqual(result.params, [18, 65]);
+  });
+
+  it('should handle a single notBetween condition', () => {
+    const result = buildWhere(OP.notBetween('price', [0, 10]));
+    assert.strictEqual(result.sql, '`price` NOT BETWEEN ? AND ?');
+    assert.deepStrictEqual(result.params, [0, 10]);
+  });
+
+  it('should handle array with AND connector', () => {
+    const result = buildWhere([
+      OP.eq('name', 'Alice'),
+      'AND',
+      OP.gt('age', 18),
+    ]);
+    assert.strictEqual(result.sql, '`name` = ? AND `age` > ?');
+    assert.deepStrictEqual(result.params, ['Alice', 18]);
+  });
+
+  it('should handle array with OR connector', () => {
+    const result = buildWhere([
+      OP.eq('role', 'admin'),
+      'OR',
+      OP.eq('role', 'superadmin'),
+    ]);
+    assert.strictEqual(result.sql, '`role` = ? OR `role` = ?');
+    assert.deepStrictEqual(result.params, ['admin', 'superadmin']);
+  });
+
+  it('should handle array with XOR connector', () => {
+    const result = buildWhere([OP.eq('a', 1), 'XOR', OP.eq('b', 2)]);
+    assert.strictEqual(result.sql, '`a` = ? XOR `b` = ?');
+    assert.deepStrictEqual(result.params, [1, 2]);
+  });
+
+  it('should handle array with NOT connector', () => {
+    const result = buildWhere(['NOT', OP.eq('active', 0)]);
+    assert.strictEqual(result.sql, 'NOT `active` = ?');
+    assert.deepStrictEqual(result.params, [0]);
+  });
+
+  it('should handle multiple AND conditions', () => {
+    const result = buildWhere([
+      OP.eq('name', 'Alice'),
+      'AND',
+      OP.gt('age', 18),
+      'AND',
+      OP.isNotNull('email'),
+    ]);
+    assert.strictEqual(
+      result.sql,
+      '`name` = ? AND `age` > ? AND `email` IS NOT NULL'
+    );
+    assert.deepStrictEqual(result.params, ['Alice', 18]);
+  });
+
+  it('should handle mixed AND and OR connectors', () => {
+    const result = buildWhere([
+      OP.eq('status', 'active'),
+      'AND',
+      OP.gt('age', 18),
+      'OR',
+      OP.eq('role', 'admin'),
+    ]);
+    assert.strictEqual(result.sql, '`status` = ? AND `age` > ? OR `role` = ?');
+    assert.deepStrictEqual(result.params, ['active', 18, 'admin']);
+  });
+
+  it('should handle nested groups', () => {
+    const result = buildWhere([
+      OP.eq('a', 1),
+      'OR',
+      [OP.eq('b', 2), 'AND', OP.eq('c', 3)],
+    ]);
+    assert.strictEqual(result.sql, '`a` = ? OR (`b` = ? AND `c` = ?)');
+    assert.deepStrictEqual(result.params, [1, 2, 3]);
+  });
+
+  it('should handle deeply nested groups', () => {
+    const result = buildWhere([
+      OP.eq('a', 1),
+      'AND',
+      [OP.eq('b', 2), 'OR', [OP.eq('c', 3), 'AND', OP.eq('d', 4)]],
+    ]);
+    assert.strictEqual(
+      result.sql,
+      '`a` = ? AND (`b` = ? OR (`c` = ? AND `d` = ?))'
+    );
+    assert.deepStrictEqual(result.params, [1, 2, 3, 4]);
+  });
+
+  it('should handle multiple nested groups', () => {
+    const result = buildWhere([
+      [OP.eq('a', 1), 'AND', OP.eq('b', 2)],
+      'OR',
+      [OP.eq('c', 3), 'AND', OP.eq('d', 4)],
+    ]);
+    assert.strictEqual(
+      result.sql,
+      '(`a` = ? AND `b` = ?) OR (`c` = ? AND `d` = ?)'
+    );
+    assert.deepStrictEqual(result.params, [1, 2, 3, 4]);
+  });
+
+  it('should handle nested group with mixed operators', () => {
+    const result = buildWhere([
+      OP.isNotNull('email'),
+      'AND',
+      [OP.like('name', '%Alice%'), 'OR', OP.in('role', ['admin', 'editor'])],
+    ]);
+    assert.strictEqual(
+      result.sql,
+      '`email` IS NOT NULL AND (`name` LIKE ? OR `role` IN (?, ?))'
+    );
+    assert.deepStrictEqual(result.params, ['%Alice%', 'admin', 'editor']);
+  });
+
+  it('should handle between inside a group with AND', () => {
+    const result = buildWhere([
+      OP.between('age', [18, 65]),
+      'AND',
+      OP.eq('active', 1),
+    ]);
+    assert.strictEqual(result.sql, '`age` BETWEEN ? AND ? AND `active` = ?');
+    assert.deepStrictEqual(result.params, [18, 65, 1]);
+  });
+
+  it('should handle notIn with nested group', () => {
+    const result = buildWhere([
+      OP.notIn('id', [10, 20, 30]),
+      'AND',
+      [OP.gte('score', 50), 'OR', OP.isNull('score')],
+    ]);
+    assert.strictEqual(
+      result.sql,
+      '`id` NOT IN (?, ?, ?) AND (`score` >= ? OR `score` IS NULL)'
+    );
+    assert.deepStrictEqual(result.params, [10, 20, 30, 50]);
+  });
+
+  it('should handle single condition inside an array', () => {
+    const result = buildWhere([OP.eq('x', 1)]);
+    assert.strictEqual(result.sql, '`x` = ?');
+    assert.deepStrictEqual(result.params, [1]);
+  });
+});

package/test/unit/operators.test.ts

@@ -0,0 +1,98 @@
+import { assert, describe, it } from 'poku';
+import { OP } from '../../src/queries/where/operators.js';
+
+describe('OP (operators)', () => {
+  it('should build eq condition', () => {
+    const cond = OP.eq('name', 'Alice');
+    assert.strictEqual(cond.condition, '`name` = ?');
+    assert.deepStrictEqual(cond.params, ['Alice']);
+  });
+
+  it('should build ne condition', () => {
+    const cond = OP.ne('name', 'Alice');
+    assert.strictEqual(cond.condition, '`name` != ?');
+  });
+
+  it('should build gt condition', () => {
+    const cond = OP.gt('age', 18);
+    assert.strictEqual(cond.condition, '`age` > ?');
+    assert.deepStrictEqual(cond.params, [18]);
+  });
+
+  it('should build lt condition', () => {
+    const cond = OP.lt('age', 18);
+    assert.strictEqual(cond.condition, '`age` < ?');
+  });
+
+  it('should build gte condition', () => {
+    const cond = OP.gte('age', 18);
+    assert.strictEqual(cond.condition, '`age` >= ?');
+  });
+
+  it('should build lte condition', () => {
+    const cond = OP.lte('age', 18);
+    assert.strictEqual(cond.condition, '`age` <= ?');
+  });
+
+  it('should build like condition', () => {
+    const cond = OP.like('name', '%Ali%');
+    assert.strictEqual(cond.condition, '`name` LIKE ?');
+    assert.deepStrictEqual(cond.params, ['%Ali%']);
+  });
+
+  it('should build notLike condition', () => {
+    const cond = OP.notLike('name', '%Ali%');
+    assert.strictEqual(cond.condition, '`name` NOT LIKE ?');
+  });
+
+  it('should build isNull condition', () => {
+    const cond = OP.isNull('email');
+    assert.strictEqual(cond.condition, '`email` IS NULL');
+    assert.deepStrictEqual(cond.params, []);
+  });
+
+  it('should build isNotNull condition', () => {
+    const cond = OP.isNotNull('email');
+    assert.strictEqual(cond.condition, '`email` IS NOT NULL');
+    assert.deepStrictEqual(cond.params, []);
+  });
+
+  it('should build in condition with values', () => {
+    const cond = OP.in('id', [1, 2, 3]);
+    assert.strictEqual(cond.condition, '`id` IN (?, ?, ?)');
+    assert.deepStrictEqual(cond.params, [1, 2, 3]);
+  });
+
+  it('should build in condition with subquery', () => {
+    const cond = OP.in('id', 'SELECT id FROM other WHERE x = ?', [42]);
+    assert.strictEqual(
+      cond.condition,
+      '`id` IN (SELECT id FROM other WHERE x = ?)'
+    );
+    assert.deepStrictEqual(cond.params, [42]);
+  });
+
+  it('should build notIn condition with values', () => {
+    const cond = OP.notIn('id', [1, 2]);
+    assert.strictEqual(cond.condition, '`id` NOT IN (?, ?)');
+    assert.deepStrictEqual(cond.params, [1, 2]);
+  });
+
+  it('should build notIn condition with subquery', () => {
+    const cond = OP.notIn('id', 'SELECT id FROM other', []);
+    assert.strictEqual(cond.condition, '`id` NOT IN (SELECT id FROM other)');
+    assert.deepStrictEqual(cond.params, []);
+  });
+
+  it('should build between condition', () => {
+    const cond = OP.between('age', [18, 65]);
+    assert.strictEqual(cond.condition, '`age` BETWEEN ? AND ?');
+    assert.deepStrictEqual(cond.params, [18, 65]);
+  });
+
+  it('should build notBetween condition', () => {
+    const cond = OP.notBetween('age', [18, 65]);
+    assert.strictEqual(cond.condition, '`age` NOT BETWEEN ? AND ?');
+    assert.deepStrictEqual(cond.params, [18, 65]);
+  });
+});

package/test/unit/prepare.test.ts

@@ -0,0 +1,22 @@
+import { assert, describe, it } from 'poku';
+import { prepare } from '../../src/drivers/_utils.js';
+
+describe('prepare', () => {
+  const mockBound = {} as D1PreparedStatement;
+  const mockStatement = {
+    bind: (..._params: unknown[]) => mockBound,
+  } as D1PreparedStatement;
+  const mockDb = {
+    prepare: (_sql: string) => mockStatement,
+  } as unknown as D1Database;
+
+  it('should bind params when params are provided', () => {
+    const result = prepare(mockDb, 'SELECT * FROM users WHERE id = ?', [1]);
+    assert.strictEqual(result, mockBound);
+  });
+
+  it('should return statement without bind when no params', () => {
+    const result = prepare(mockDb, 'SELECT * FROM users', []);
+    assert.strictEqual(result, mockStatement);
+  });
+});

package/test/unit/quoteIdentifier.test.ts

@@ -0,0 +1,12 @@
+import { assert, describe, it } from 'poku';
+import { quoteIdentifier } from '../../src/queries/_utils.js';
+
+describe('quoteIdentifier', () => {
+  it('should quote a simple name', () => {
+    assert.strictEqual(quoteIdentifier('users'), '`users`');
+  });
+
+  it('should quote a dotted name', () => {
+    assert.strictEqual(quoteIdentifier('users.id'), '`users`.`id`');
+  });
+});

package/test/unit/returnsRows.test.ts

@@ -0,0 +1,41 @@
+import { assert, describe, it } from 'poku';
+import { returnsRows } from '../../src/drivers/_utils.js';
+
+describe('returnsRows', () => {
+  it('should return true for SELECT', () => {
+    assert.strictEqual(returnsRows('SELECT * FROM users'), true);
+  });
+
+  it('should return true for WITH', () => {
+    assert.strictEqual(
+      returnsRows('WITH cte AS (SELECT 1) SELECT * FROM cte'),
+      true
+    );
+  });
+
+  it('should return true for PRAGMA', () => {
+    assert.strictEqual(returnsRows('PRAGMA table_info(users)'), true);
+  });
+
+  it('should return true for RETURNING', () => {
+    assert.strictEqual(
+      returnsRows('INSERT INTO users (name) VALUES (?) RETURNING *'),
+      true
+    );
+  });
+
+  it('should return false for INSERT', () => {
+    assert.strictEqual(
+      returnsRows('INSERT INTO users (name) VALUES (?)'),
+      false
+    );
+  });
+
+  it('should return false for UPDATE', () => {
+    assert.strictEqual(returnsRows('UPDATE users SET name = ?'), false);
+  });
+
+  it('should return false for DELETE', () => {
+    assert.strictEqual(returnsRows('DELETE FROM users'), false);
+  });
+});

package/test/unit/setMeta.test.ts

@@ -0,0 +1,31 @@
+import { assert, describe, it } from 'poku';
+import { setMeta } from '../../src/drivers/_utils.js';
+
+describe('setMeta', () => {
+  it('should map cursor fields to Meta object', () => {
+    const mockCursor = {
+      rowsRead: 5,
+      rowsWritten: 2,
+    } as SqlStorageCursor<Record<string, SqlStorageValue>>;
+
+    const meta = setMeta(mockCursor);
+    assert.strictEqual(meta.duration, 0);
+    assert.strictEqual(meta.size_after, 0);
+    assert.strictEqual(meta.rows_read, 5);
+    assert.strictEqual(meta.rows_written, 2);
+    assert.strictEqual(meta.last_row_id, 0);
+    assert.strictEqual(meta.changed_db, true);
+    assert.strictEqual(meta.changes, 2);
+  });
+
+  it('should set changed_db to false when no rows written', () => {
+    const mockCursor = {
+      rowsRead: 3,
+      rowsWritten: 0,
+    } as SqlStorageCursor<Record<string, SqlStorageValue>>;
+
+    const meta = setMeta(mockCursor);
+    assert.strictEqual(meta.changed_db, false);
+    assert.strictEqual(meta.changes, 0);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["test"]
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2022", "DOM"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "allowJs": false,
+    "strict": true,
+    "alwaysStrict": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": false,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "noImplicitAny": true,
+    "removeComments": false,
+    "sourceMap": false,
+    "esModuleInterop": true,
+    "noEmitOnError": true,
+    "declaration": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "outDir": "lib",
+    "declarationDir": "lib",
+    "typeRoots": [
+      "node_modules/@types",
+      "node_modules/@cloudflare/workers-types"
+    ]
+  },
+  "include": ["src", "test"]
+}

package/website/.prettierignore

@@ -0,0 +1,4 @@
+/build
+/.docusaurus
+/.cache-loader
+# /**/*.mdx