cl-orm 0.1.0 → 0.1.1

package/src/drivers/_utils.ts

@@ -1,31 +0,0 @@
-import type { Meta } from '../types.js';
-
-export const returnsRows = (sql: string): boolean => {
-  const trimmed = sql.trimStart().toUpperCase();
-
-  return (
-    trimmed.indexOf('SELECT') === 0 ||
-    trimmed.indexOf('WITH') === 0 ||
-    trimmed.indexOf('PRAGMA') === 0 ||
-    trimmed.indexOf('RETURNING') !== -1
-  );
-};
-
-export const prepare = (
-  db: D1Database,
-  sql: string,
-  params: unknown[]
-): D1PreparedStatement =>
-  params.length > 0 ? db.prepare(sql).bind(...params) : db.prepare(sql);
-
-export const setMeta = (
-  cursor: SqlStorageCursor<Record<string, SqlStorageValue>>
-): Meta => ({
-  duration: 0,
-  size_after: 0,
-  rows_read: cursor.rowsRead,
-  rows_written: cursor.rowsWritten,
-  last_row_id: 0,
-  changed_db: cursor.rowsWritten > 0,
-  changes: cursor.rowsWritten,
-});

package/src/drivers/d1.ts

@@ -1,70 +0,0 @@
-import type {
-  Connection,
-  DeleteOptions,
-  InsertOptions,
-  Meta,
-  QueryResult,
-  SelectOptions,
-  UpdateOptions,
-} from '../types.js';
-import { buildDelete } from '../queries/delete.js';
-import { buildInsert } from '../queries/insert.js';
-import { buildSelect } from '../queries/select.js';
-import { buildUpdate } from '../queries/update.js';
-import { prepare, returnsRows } from './_utils.js';
-
-export const useD1 = (db: D1Database): Connection => {
-  const query = async <T = Record<string, unknown>>(
-    sql: string,
-    values?: unknown[]
-  ): Promise<QueryResult<T>> => {
-    const statement = values
-      ? db.prepare(sql).bind(...values)
-      : db.prepare(sql);
-
-    if (returnsRows(sql)) {
-      const { results, meta } = await statement.all<T>();
-      return { rows: results, meta: meta as Meta };
-    }
-
-    const { meta } = await statement.run();
-    return { rows: [], meta: meta as Meta };
-  };
-
-  const select = async <T = Record<string, unknown>>(
-    options: SelectOptions
-  ): Promise<T | null | T[]> => {
-    const { sql, params } = buildSelect(options);
-    const statement = prepare(db, sql, params);
-
-    if (options.limit === 1) return statement.first<T>();
-
-    const { results } = await statement.all<T>();
-    return results;
-  };
-
-  const insert = async (options: InsertOptions): Promise<Meta> => {
-    const { sql, params } = buildInsert(options);
-    const { meta } = await query(sql, params);
-
-    return meta;
-  };
-
-  const update = async (options: UpdateOptions): Promise<Meta> => {
-    const { sql, params } = buildUpdate(options);
-    const statement = prepare(db, sql, params);
-    const { meta } = await statement.run();
-
-    return meta as Meta;
-  };
-
-  const del = async (options: DeleteOptions): Promise<Meta> => {
-    const { sql, params } = buildDelete(options);
-    const statement = prepare(db, sql, params);
-    const { meta } = await statement.run();
-
-    return meta as Meta;
-  };
-
-  return { query, select, insert, update, delete: del };
-};

package/src/drivers/do.ts

@@ -1,81 +0,0 @@
-import type {
-  Connection,
-  DeleteOptions,
-  InsertOptions,
-  Meta,
-  QueryResult,
-  SelectOptions,
-  UpdateOptions,
-} from '../types.js';
-import { buildDelete } from '../queries/delete.js';
-import { buildInsert } from '../queries/insert.js';
-import { buildSelect } from '../queries/select.js';
-import { buildUpdate } from '../queries/update.js';
-import { returnsRows, setMeta } from './_utils.js';
-
-export const useDO = (sql: SqlStorage): Connection => {
-  const exec = <T extends Record<string, SqlStorageValue>>(
-    query: string,
-    values?: unknown[]
-  ) => (values ? sql.exec<T>(query, ...values) : sql.exec<T>(query));
-
-  const query = async <T = Record<string, unknown>>(
-    queryStr: string,
-    values?: unknown[]
-  ): Promise<QueryResult<T>> => {
-    const cursor = exec(queryStr, values);
-
-    if (returnsRows(queryStr)) {
-      const rows = cursor.toArray() as T[];
-      return { rows, meta: setMeta(cursor) };
-    }
-
-    return { rows: [], meta: setMeta(cursor) };
-  };
-
-  const select = async <T = Record<string, unknown>>(
-    options: SelectOptions
-  ): Promise<T | null | T[]> => {
-    const built = buildSelect(options);
-    const cursor = exec(
-      built.sql,
-      built.params.length > 0 ? built.params : undefined
-    );
-
-    if (options.limit === 1) {
-      const rows = cursor.toArray() as T[];
-      return rows[0] ?? null;
-    }
-
-    return cursor.toArray() as T[];
-  };
-
-  const insert = async (options: InsertOptions): Promise<Meta> => {
-    const built = buildInsert(options);
-    const cursor = exec(built.sql, built.params);
-
-    return setMeta(cursor);
-  };
-
-  const update = async (options: UpdateOptions): Promise<Meta> => {
-    const built = buildUpdate(options);
-    const cursor = exec(
-      built.sql,
-      built.params.length > 0 ? built.params : undefined
-    );
-
-    return setMeta(cursor);
-  };
-
-  const del = async (options: DeleteOptions): Promise<Meta> => {
-    const built = buildDelete(options);
-    const cursor = exec(
-      built.sql,
-      built.params.length > 0 ? built.params : undefined
-    );
-
-    return setMeta(cursor);
-  };
-
-  return { query, select, insert, update, delete: del };
-};

package/src/queries/_utils.ts

@@ -1,10 +0,0 @@
-export const quoteIdentifier = (name: string): string => {
-  if (name.includes('.')) {
-    return name
-      .split('.')
-      .map((part) => `\`${part}\``)
-      .join('.');
-  }
-
-  return `\`${name}\``;
-};

package/src/queries/delete.ts

@@ -1,26 +0,0 @@
-import type { DeleteOptions } from '../types.js';
-import { quoteIdentifier } from './_utils.js';
-import { buildWhere } from './where/where.js';
-
-export const buildDelete = (
-  options: DeleteOptions
-): { sql: string; params: unknown[] } => {
-  const parts: string[] = ['DELETE FROM', quoteIdentifier(options.table)];
-  const params: unknown[] = [];
-
-  if (options.where) {
-    const where = buildWhere(options.where);
-
-    parts.push('WHERE', where.sql);
-    params.push(...where.params);
-  }
-
-  if (options.limit !== undefined) {
-    parts.push('LIMIT ?');
-    params.push(options.limit);
-  }
-
-  if (options.params) params.unshift(...options.params);
-
-  return { sql: parts.join(' '), params };
-};

package/src/queries/insert.ts

@@ -1,22 +0,0 @@
-import type { InsertOptions } from '../types.js';
-import { quoteIdentifier } from './_utils.js';
-
-export const buildInsert = (
-  options: InsertOptions
-): { sql: string; params: unknown[] } => {
-  const rows = Array.isArray(options.values)
-    ? options.values
-    : [options.values];
-  const columns = Object.keys(rows[0]);
-
-  const columnsSql = columns.map(quoteIdentifier).join(', ');
-  const placeholders = `(${columns.map(() => '?').join(', ')})`;
-  const valuesSql = rows.map(() => placeholders).join(', ');
-
-  const params = rows.flatMap((row) => columns.map((col) => row[col]));
-
-  return {
-    sql: `INSERT INTO ${quoteIdentifier(options.table)} (${columnsSql}) VALUES ${valuesSql}`,
-    params,
-  };
-};

package/src/queries/select.ts

@@ -1,64 +0,0 @@
-import type { JoinOptions, SelectOptions } from '../types.js';
-import { quoteIdentifier } from './_utils.js';
-import { buildWhere } from './where/where.js';
-
-const buildColumns = (columns?: string | string[]): string => {
-  if (!columns) return '*';
-  if (typeof columns === 'string') return columns;
-
-  return columns.map(quoteIdentifier).join(', ');
-};
-
-const buildJoin = (join: JoinOptions): string => {
-  const type = join.outer
-    ? `${join.type.toUpperCase()} OUTER`
-    : join.type.toUpperCase();
-
-  return `${type} JOIN ${quoteIdentifier(join.table)} ON ${quoteIdentifier(join.on.a)} = ${quoteIdentifier(join.on.b)}`;
-};
-
-export const buildSelect = (
-  options: SelectOptions
-): { sql: string; params: unknown[] } => {
-  const parts: string[] = ['SELECT'];
-  const params: unknown[] = [];
-
-  if (options.distinct) parts.push('DISTINCT');
-
-  parts.push(buildColumns(options.columns));
-  parts.push('FROM', quoteIdentifier(options.table));
-
-  if (options.join) {
-    const joins = Array.isArray(options.join) ? options.join : [options.join];
-    for (const join of joins) {
-      parts.push(buildJoin(join));
-    }
-  }
-
-  if (options.where) {
-    const where = buildWhere(options.where);
-    parts.push('WHERE', where.sql);
-    params.push(...where.params);
-  }
-
-  if (options.groupBy) parts.push('GROUP BY', quoteIdentifier(options.groupBy));
-
-  if (options.orderBy) {
-    const [column, direction = 'ASC'] = options.orderBy;
-    parts.push('ORDER BY', quoteIdentifier(column), direction);
-  }
-
-  if (options.limit !== undefined) {
-    parts.push('LIMIT ?');
-    params.push(options.limit);
-  }
-
-  if (options.offset !== undefined) {
-    parts.push('OFFSET ?');
-    params.push(options.offset);
-  }
-
-  if (options.params) params.unshift(...options.params);
-
-  return { sql: parts.join(' '), params };
-};

package/src/queries/update.ts

@@ -1,28 +0,0 @@
-import type { UpdateOptions } from '../types.js';
-import { quoteIdentifier } from './_utils.js';
-import { buildWhere } from './where/where.js';
-
-export const buildUpdate = (
-  options: UpdateOptions
-): { sql: string; params: unknown[] } => {
-  const columns = Object.keys(options.set);
-  const setSql = columns.map((col) => `${quoteIdentifier(col)} = ?`).join(', ');
-  const params: unknown[] = columns.map((col) => options.set[col]);
-
-  const parts: string[] = [
-    'UPDATE',
-    quoteIdentifier(options.table),
-    'SET',
-    setSql,
-  ];
-
-  if (options.where) {
-    const where = buildWhere(options.where);
-    parts.push('WHERE', where.sql);
-    params.push(...where.params);
-  }
-
-  if (options.params) params.push(...options.params);
-
-  return { sql: parts.join(' '), params };
-};

package/src/queries/where/operators.ts

@@ -1,96 +0,0 @@
-import type { Condition, Param } from '../../types.js';
-import { quoteIdentifier } from '../_utils.js';
-
-const comparison = (
-  column: string,
-  operator: string,
-  param: Param
-): Condition => ({
-  condition: `${quoteIdentifier(column)} ${operator} ?`,
-  params: [param],
-});
-
-export const OP = {
-  eq: (column: string, param: Param): Condition =>
-    comparison(column, '=', param),
-  ne: (column: string, param: Param): Condition =>
-    comparison(column, '!=', param),
-  gt: (column: string, param: Param): Condition =>
-    comparison(column, '>', param),
-  lt: (column: string, param: Param): Condition =>
-    comparison(column, '<', param),
-  gte: (column: string, param: Param): Condition =>
-    comparison(column, '>=', param),
-  lte: (column: string, param: Param): Condition =>
-    comparison(column, '<=', param),
-  like: (column: string, param: Param): Condition =>
-    comparison(column, 'LIKE', param),
-  notLike: (column: string, param: Param): Condition =>
-    comparison(column, 'NOT LIKE', param),
-
-  isNull: (column: string): Condition => ({
-    condition: `${quoteIdentifier(column)} IS NULL`,
-    params: [],
-  }),
-
-  isNotNull: (column: string): Condition => ({
-    condition: `${quoteIdentifier(column)} IS NOT NULL`,
-    params: [],
-  }),
-
-  in: ((
-    column: string,
-    valuesOrSubquery: Param[] | string,
-    subqueryParams?: Param[]
-  ): Condition => {
-    if (typeof valuesOrSubquery === 'string') {
-      return {
-        condition: `${quoteIdentifier(column)} IN (${valuesOrSubquery})`,
-        params: subqueryParams ?? [],
-      };
-    }
-
-    const placeholders = valuesOrSubquery.map(() => '?').join(', ');
-
-    return {
-      condition: `${quoteIdentifier(column)} IN (${placeholders})`,
-      params: valuesOrSubquery,
-    };
-  }) as {
-    (column: string, params: Param[]): Condition;
-    (column: string, subquery: string, params: Param[]): Condition;
-  },
-
-  notIn: ((
-    column: string,
-    valuesOrSubquery: Param[] | string,
-    subqueryParams?: Param[]
-  ): Condition => {
-    if (typeof valuesOrSubquery === 'string') {
-      return {
-        condition: `${quoteIdentifier(column)} NOT IN (${valuesOrSubquery})`,
-        params: subqueryParams ?? [],
-      };
-    }
-
-    const placeholders = valuesOrSubquery.map(() => '?').join(', ');
-
-    return {
-      condition: `${quoteIdentifier(column)} NOT IN (${placeholders})`,
-      params: valuesOrSubquery,
-    };
-  }) as {
-    (column: string, params: Param[]): Condition;
-    (column: string, subquery: string, params: Param[]): Condition;
-  },
-
-  between: (column: string, params: [Param, Param]): Condition => ({
-    condition: `${quoteIdentifier(column)} BETWEEN ? AND ?`,
-    params,
-  }),
-
-  notBetween: (column: string, params: [Param, Param]): Condition => ({
-    condition: `${quoteIdentifier(column)} NOT BETWEEN ? AND ?`,
-    params,
-  }),
-};

package/src/queries/where/where.ts

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

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

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

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