rado 0.1.62 → 0.1.64

package/dist/lib/Query.d.ts

@@ -1,109 +0,0 @@
-import { ColumnData } from './Column';
-import { ExprData } from './Expr';
-import { IndexData } from './Index';
-import { OrderBy } from './OrderBy';
-import { Schema } from './Schema';
-import { Target } from './Target';
-export declare enum QueryType {
-    Insert = "Insert",
-    Select = "Select",
-    Update = "Update",
-    Delete = "Delete",
-    CreateTable = "CreateTable",
-    CreateIndex = "CreateIndex",
-    DropIndex = "DropIndex",
-    AlterTable = "AlterTable",
-    Batch = "Batch",
-    Transaction = "Transaction",
-    Raw = "Raw"
-}
-export type Query<T = any> = Query.Insert | Query.Select | Query.Update | Query.Delete | Query.CreateTable | Query.CreateIndex | Query.DropIndex | Query.AlterTable | Query.Batch | Query.Transaction | Query.Raw;
-export declare namespace Query {
-    interface QueryBase {
-        limit?: number;
-        offset?: number;
-        type: QueryType;
-        where?: ExprData;
-        orderBy?: Array<OrderBy>;
-        groupBy?: Array<ExprData>;
-        having?: ExprData;
-        selection?: ExprData;
-        singleResult?: boolean;
-        validate?: boolean;
-    }
-    interface Insert extends QueryBase {
-        type: QueryType.Insert;
-        into: Schema;
-        data: Array<any>;
-    }
-    function Insert(insert: Omit<Insert, 'type'>): Query.Insert;
-    interface Select extends QueryBase {
-        type: QueryType.Select;
-        selection: ExprData;
-        from: Target;
-    }
-    function Select(select: Omit<Select, 'type'>): Query.Select;
-    interface Update extends QueryBase {
-        type: QueryType.Update;
-        table: Schema;
-        set?: Record<string, any>;
-    }
-    function Update(update: Omit<Update, 'type'>): Query.Update;
-    interface Delete extends QueryBase {
-        type: QueryType.Delete;
-        table: Schema;
-    }
-    function Delete(del: Omit<Delete, 'type'>): Query.Delete;
-    interface CreateTable extends QueryBase {
-        type: QueryType.CreateTable;
-        table: Schema;
-        ifNotExists?: boolean;
-    }
-    function CreateTable(create: Omit<CreateTable, 'type'>): Query.CreateTable;
-    interface CreateIndex extends QueryBase {
-        type: QueryType.CreateIndex;
-        table: Schema;
-        index: IndexData;
-        ifNotExists?: boolean;
-    }
-    function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;
-    interface DropIndex extends QueryBase {
-        type: QueryType.DropIndex;
-        table: Schema;
-        name: string;
-        ifExists?: boolean;
-    }
-    function DropIndex(drop: Omit<DropIndex, 'type'>): Query.DropIndex;
-    interface Batch extends QueryBase {
-        type: QueryType.Batch;
-        queries: Array<Query<any>>;
-    }
-    function Batch(batch: Omit<Batch, 'type'>): Query.Batch;
-    enum TransactionOperation {
-        Begin = "Begin",
-        Commit = "Commit",
-        Rollback = "Rollback"
-    }
-    interface Transaction extends QueryBase {
-        type: QueryType.Transaction;
-        id: string;
-        op: TransactionOperation;
-    }
-    function Transaction(transaction: Omit<Transaction, 'type'>): Query.Transaction;
-    type RawReturn = 'row' | 'rows' | undefined;
-    interface Raw extends QueryBase {
-        type: QueryType.Raw;
-        expectedReturn?: 'row' | 'rows';
-        strings: ReadonlyArray<string>;
-        params: Array<any>;
-    }
-    function Raw(raw: Omit<Raw, 'type'>): Query.Raw;
-    interface AlterTable extends QueryBase {
-        type: QueryType.AlterTable;
-        table: Schema;
-        alterColumn?: ColumnData;
-        addColumn?: ColumnData;
-        dropColumn?: string;
-    }
-    function AlterTable(alter: Omit<AlterTable, 'type'>): Query.AlterTable;
-}

package/dist/lib/Query.js

@@ -1,74 +0,0 @@
-// src/lib/Query.ts
-var QueryType = /* @__PURE__ */ ((QueryType2) => {
-  QueryType2["Insert"] = "Insert";
-  QueryType2["Select"] = "Select";
-  QueryType2["Update"] = "Update";
-  QueryType2["Delete"] = "Delete";
-  QueryType2["CreateTable"] = "CreateTable";
-  QueryType2["CreateIndex"] = "CreateIndex";
-  QueryType2["DropIndex"] = "DropIndex";
-  QueryType2["AlterTable"] = "AlterTable";
-  QueryType2["Batch"] = "Batch";
-  QueryType2["Transaction"] = "Transaction";
-  QueryType2["Raw"] = "Raw";
-  return QueryType2;
-})(QueryType || {});
-var Query;
-((Query2) => {
-  function Insert(insert) {
-    return { type: "Insert" /* Insert */, ...insert };
-  }
-  Query2.Insert = Insert;
-  function Select(select) {
-    return { type: "Select" /* Select */, ...select };
-  }
-  Query2.Select = Select;
-  function Update(update) {
-    return { type: "Update" /* Update */, ...update };
-  }
-  Query2.Update = Update;
-  function Delete(del) {
-    return { type: "Delete" /* Delete */, ...del };
-  }
-  Query2.Delete = Delete;
-  function CreateTable(create) {
-    return { type: "CreateTable" /* CreateTable */, ...create };
-  }
-  Query2.CreateTable = CreateTable;
-  function CreateIndex(create) {
-    return { type: "CreateIndex" /* CreateIndex */, ...create };
-  }
-  Query2.CreateIndex = CreateIndex;
-  function DropIndex(drop) {
-    return { type: "DropIndex" /* DropIndex */, ...drop };
-  }
-  Query2.DropIndex = DropIndex;
-  function Batch(batch) {
-    return { type: "Batch" /* Batch */, ...batch };
-  }
-  Query2.Batch = Batch;
-  let TransactionOperation;
-  ((TransactionOperation2) => {
-    TransactionOperation2["Begin"] = "Begin";
-    TransactionOperation2["Commit"] = "Commit";
-    TransactionOperation2["Rollback"] = "Rollback";
-  })(TransactionOperation = Query2.TransactionOperation || (Query2.TransactionOperation = {}));
-  function Transaction(transaction) {
-    return { type: "Transaction" /* Transaction */, ...transaction };
-  }
-  Query2.Transaction = Transaction;
-  function Raw(raw) {
-    if (raw.strings.some((chunk) => chunk.includes("?")))
-      throw new TypeError("SQL injection hazard");
-    return { type: "Raw" /* Raw */, ...raw };
-  }
-  Query2.Raw = Raw;
-  function AlterTable(alter) {
-    return { type: "AlterTable" /* AlterTable */, ...alter };
-  }
-  Query2.AlterTable = AlterTable;
-})(Query || (Query = {}));
-export {
-  Query,
-  QueryType
-};

package/dist/lib/Schema.d.ts

@@ -1,18 +0,0 @@
-import { ColumnData } from './Column';
-import { Formatter } from './Formatter';
-import { IndexData } from './Index';
-import { Query } from './Query';
-export interface Schema {
-    name: string;
-    alias?: string;
-    columns: Record<string, ColumnData>;
-    indexes: Record<string, IndexData>;
-}
-export interface SchemaInstructions {
-    columns: Record<string, string>;
-    indexes: Record<string, string>;
-}
-export declare namespace Schema {
-    function create(schema: Schema): Query.Batch;
-    function upgrade(formatter: Formatter, local: SchemaInstructions, schema: Schema): Array<Query>;
-}

package/dist/lib/Schema.js

@@ -1,67 +0,0 @@
-// src/lib/Schema.ts
-import { Query } from "./Query.js";
-import { Statement } from "./Statement.js";
-var Schema;
-((Schema2) => {
-  function create(schema) {
-    const queries = [];
-    queries.push(Query.CreateTable({ table: schema, ifNotExists: true }));
-    for (const index of Object.values(schema.indexes))
-      queries.push(Query.CreateIndex({ table: schema, index, ifNotExists: true }));
-    return Query.Batch({ queries });
-  }
-  Schema2.create = create;
-  function removeLeadingWhitespace(str) {
-    return str.replace(/\n\s+/g, "\n");
-  }
-  function upgrade(formatter, local, schema) {
-    const columnNames = /* @__PURE__ */ new Set([
-      ...Object.keys(local.columns),
-      ...Object.keys(schema.columns)
-    ]);
-    const res = [];
-    for (const columnName of columnNames) {
-      const localInstruction = local.columns[columnName];
-      const schemaCol = schema.columns[columnName];
-      if (!localInstruction) {
-        res.push(Query.AlterTable({ table: schema, addColumn: schemaCol }));
-      } else if (!schemaCol) {
-        res.push(Query.AlterTable({ table: schema, dropColumn: columnName }));
-      } else {
-        const { sql: instruction } = formatter.formatColumn(
-          { stmt: new Statement(formatter) },
-          { ...schemaCol, references: void 0 }
-        );
-        if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
-          res.push(Query.AlterTable({ table: schema, alterColumn: schemaCol }));
-        }
-      }
-    }
-    const indexNames = /* @__PURE__ */ new Set([
-      ...Object.keys(local.indexes),
-      ...Object.keys(schema.indexes)
-    ]);
-    for (const indexName of indexNames) {
-      const localInstruction = local.indexes[indexName];
-      const schemaIndex = schema.indexes[indexName];
-      if (!localInstruction) {
-        res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
-      } else if (!schemaIndex) {
-        res.unshift(Query.DropIndex({ table: schema, name: indexName }));
-      } else {
-        const { sql: instruction } = formatter.compile(
-          Query.CreateIndex({ table: schema, index: schemaIndex })
-        );
-        if (removeLeadingWhitespace(localInstruction) !== removeLeadingWhitespace(instruction)) {
-          res.unshift(Query.DropIndex({ table: schema, name: indexName }));
-          res.push(Query.CreateIndex({ table: schema, index: schemaIndex }));
-        }
-      }
-    }
-    return res;
-  }
-  Schema2.upgrade = upgrade;
-})(Schema || (Schema = {}));
-export {
-  Schema
-};

package/dist/lib/Selection.d.ts

@@ -1,20 +0,0 @@
-import type { Cursor } from './Cursor';
-import type { Expr } from './Expr';
-type SelectionBase = Expr<any> | Cursor.SelectMultiple<any> | Cursor.SelectSingle<any>;
-interface SelectionRecord extends Record<string, Selection> {
-}
-export type Selection = SelectionBase | SelectionRecord;
-export declare namespace Selection {
-    const __tableType: unique symbol;
-    const __cursorType: unique symbol;
-    type Infer<T> = T extends {
-        [__tableType](): infer K;
-    } ? K : T extends {
-        [__cursorType](): infer K;
-    } ? K : T extends Expr<infer K> ? K : T extends Record<string, Selection> ? {
-        [K in keyof T]: Infer<T[K]>;
-    } : T;
-    type With<A, B> = Expr<Combine<A, B>>;
-    type Combine<A, B> = Omit<A, keyof Infer<B>> & Infer<B>;
-}
-export {};

package/dist/lib/Selection.js

@@ -1,7 +0,0 @@
-// src/lib/Selection.ts
-var Selection;
-((Selection2) => {
-})(Selection || (Selection = {}));
-export {
-  Selection
-};

package/dist/lib/Table.d.ts

@@ -1,62 +0,0 @@
-import { Column, PrimaryKey } from './Column';
-import { Cursor } from './Cursor';
-import { EV, Expr } from './Expr';
-import { Fields } from './Fields';
-import { Index } from './Index';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Update } from './Update';
-export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
-    [Selection.__tableType](): Table.Normalize<T>;
-    constructor(schema: Schema);
-    fetch(id: EV<T extends {
-        id: Column.IsPrimary<infer V, any>;
-    } ? V : never>): Cursor.SelectSingle<Table.Normalize<T> | undefined>;
-    insertOne(record: Table.Insert<T>): Cursor<Table.Normalize<T>>;
-    insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
-    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
-    delete(): Cursor.Delete;
-    createTable(): Cursor.Create;
-    as(alias: string): this;
-    alias(): Record<string, this>;
-    get(name: string): Expr<any>;
-    toExpr(): Expr<Table.Normalize<T>>;
-    schema(): Schema;
-}
-export declare namespace Table {
-    type Intersection<A, B> = A & B extends infer U ? {
-        [P in keyof U]: EV<U[P]>;
-    } : never;
-    type OptionalKeys<T> = {
-        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
-    }[keyof T];
-    type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.IsPrimary<any, any> ? never : T[K] extends Column.IsOptional<any> ? never : K;
-    }[keyof T];
-    type Optionals<T> = {
-        [K in keyof T]?: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
-    };
-    export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
-    export type Normalize<T> = {
-        [K in keyof T]: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
-    };
-    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
-    export {};
-}
-export type TableOptions<T, R> = {
-    name: string;
-    alias?: string;
-    columns: {
-        [K in keyof T]: Column<T[K]>;
-    };
-    indexes?: (this: Fields<T>) => Record<string, Index>;
-};
-export declare function table<T extends {}, R>(options: TableOptions<T, R>): Table<T> & Fields<T>;
-export declare namespace table {
-    export type infer<T> = Table.Infer<T>;
-    type Extensions<T> = {
-        [key: string]: (this: T, ...args: any[]) => any;
-    };
-    export function extend<T extends Table<any>, E extends Extensions<T>>(target: T, extensions: E): T & E;
-    export {};
-}

package/dist/lib/Table.js

@@ -1,130 +0,0 @@
-// src/lib/Table.ts
-import { Cursor } from "./Cursor.js";
-import { Expr, ExprData } from "./Expr.js";
-import { Query } from "./Query.js";
-import { Selection } from "./Selection.js";
-import { Target } from "./Target.js";
-var Table = class extends Cursor.SelectMultiple {
-  [Selection.__tableType]() {
-    throw "assert";
-  }
-  constructor(schema) {
-    super(
-      Query.Select({
-        from: Target.Table(schema),
-        selection: ExprData.Row(Target.Table(schema))
-      })
-    );
-    Object.defineProperty(this, "schema", {
-      enumerable: false,
-      value: () => schema
-    });
-    if (schema.columns)
-      for (const column of Object.keys(schema.columns)) {
-        Object.defineProperty(this, column, {
-          enumerable: true,
-          get: () => this.get(column)
-        });
-      }
-    return new Proxy(this, {
-      get(target, key) {
-        return key in target ? target[key] : target.get(key);
-      }
-    });
-  }
-  fetch(id) {
-    return this.where(this.get("id").is(id)).first();
-  }
-  insertOne(record) {
-    return new Cursor(
-      Query.Insert({
-        into: this.schema(),
-        data: [record],
-        selection: ExprData.Row(Target.Table(this.schema())),
-        singleResult: true
-      })
-    );
-  }
-  insertAll(data) {
-    return new Cursor.Insert(this.schema()).values(...data);
-  }
-  set(data) {
-    return new Cursor.Update(
-      Query.Update({
-        table: this.schema()
-      })
-    ).set(data);
-  }
-  delete() {
-    return new Cursor.Delete(Query.Delete({ table: this.schema() }));
-  }
-  createTable() {
-    return new Cursor.Create(this.schema());
-  }
-  as(alias) {
-    return new Table({ ...this.schema(), alias });
-  }
-  alias() {
-    return new Proxy(
-      {},
-      {
-        get: (_, key) => {
-          return this.as(key);
-        }
-      }
-    );
-  }
-  get(name) {
-    return new Expr(ExprData.Field(this.toExpr().expr, name));
-  }
-  toExpr() {
-    return new Expr(
-      ExprData.Row(Target.Table(this.schema()))
-    );
-  }
-  schema() {
-    throw new Error("Not implemented");
-  }
-};
-function table(options) {
-  const schema = {
-    ...options,
-    columns: Object.fromEntries(
-      Object.entries(options.columns).map(([key, column]) => {
-        const { data } = column;
-        return [key, { ...data, name: data.name || key }];
-      })
-    ),
-    indexes: {}
-  };
-  const indexes = Object.fromEntries(
-    Object.entries(
-      options.indexes ? options.indexes.call(
-        new Expr(ExprData.Row(Target.Table(schema)))
-      ) : {}
-    ).map(([key, index]) => {
-      const indexName = `${schema.name}.${key}`;
-      return [indexName, { name: indexName, ...index.data }];
-    })
-  );
-  return new Table({
-    ...schema,
-    indexes
-  });
-}
-((table2) => {
-  function extend(target, extensions) {
-    return new Proxy(target, {
-      get(target2, key) {
-        if (key === "as")
-          return (...args) => extend(target2.as(...args), extensions);
-        return key in extensions ? extensions[key].bind(target2) : target2[key];
-      }
-    });
-  }
-  table2.extend = extend;
-})(table || (table = {}));
-export {
-  Table,
-  table
-};

package/dist/lib/Target.d.ts

@@ -1,30 +0,0 @@
-import { ExprData } from './Expr';
-import { Schema } from './Schema';
-export declare enum TargetType {
-    Each = "Each",
-    Table = "Table",
-    Join = "Join"
-}
-export type Target = Target.Each | Target.Table | Target.Join;
-export declare namespace Target {
-    interface Each {
-        type: TargetType.Each;
-        expr: ExprData;
-        alias: string;
-    }
-    function Each(expr: ExprData, alias: string): Each;
-    interface Table {
-        type: TargetType.Table;
-        table: Schema;
-    }
-    function Table(table: Schema): Table;
-    interface Join {
-        type: TargetType.Join;
-        left: Target;
-        right: Target;
-        joinType: 'left' | 'inner';
-        on: ExprData;
-    }
-    function Join(left: Target, right: Target, joinType: 'left' | 'inner', on: ExprData): Join;
-    function source(from: Target): Schema | undefined;
-}

package/dist/lib/Target.js

@@ -1,37 +0,0 @@
-// src/lib/Target.ts
-var TargetType = /* @__PURE__ */ ((TargetType2) => {
-  TargetType2["Each"] = "Each";
-  TargetType2["Table"] = "Table";
-  TargetType2["Join"] = "Join";
-  return TargetType2;
-})(TargetType || {});
-var Target;
-((Target2) => {
-  function Each(expr, alias) {
-    return { type: "Each" /* Each */, expr, alias };
-  }
-  Target2.Each = Each;
-  function Table(table) {
-    return { type: "Table" /* Table */, table };
-  }
-  Target2.Table = Table;
-  function Join(left, right, joinType, on) {
-    return { type: "Join" /* Join */, left, right, joinType, on };
-  }
-  Target2.Join = Join;
-  function source(from) {
-    switch (from.type) {
-      case "Table" /* Table */:
-        return from.table;
-      case "Join" /* Join */:
-        return source(from.left);
-      default:
-        return void 0;
-    }
-  }
-  Target2.source = source;
-})(Target || (Target = {}));
-export {
-  Target,
-  TargetType
-};

package/dist/lib/Update.d.ts

@@ -1,4 +0,0 @@
-import type { EV } from './Expr';
-export type Update<Row> = Partial<{
-    [K in keyof Row]: EV<Row[K]>;
-}>;

package/dist/sqlite/index.d.ts

@@ -1,2 +0,0 @@
-export * from './SqliteFormatter';
-export * from './SqliteFunctions';

package/dist/sqlite/index.js

@@ -1,3 +0,0 @@
-// src/sqlite/index.ts
-export * from "./SqliteFormatter.js";
-export * from "./SqliteFunctions.js";

package/dist/src/driver/better-sqlite3.js

@@ -1,49 +0,0 @@
-// src/driver/better-sqlite3.ts
-import { Driver } from "../lib/Driver.js";
-import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
-import { SqliteSchema } from "../sqlite/SqliteSchema.js";
-var PreparedStatement = class {
-  constructor(stmt) {
-    this.stmt = stmt;
-  }
-  all(params = []) {
-    return this.stmt.all(...params);
-  }
-  run(params = []) {
-    return { rowsAffected: this.stmt.run(...params).changes };
-  }
-  get(params = []) {
-    return this.stmt.get(...params);
-  }
-  execute(params = []) {
-    this.stmt.run(...params);
-  }
-};
-var BetterSqlite3Driver = class extends Driver.Sync {
-  constructor(db) {
-    super(new SqliteFormatter());
-    this.db = db;
-    this.tableData = this.prepare(SqliteSchema.tableData);
-    this.indexData = this.prepare(SqliteSchema.indexData);
-  }
-  tableData;
-  indexData;
-  prepareStatement(stmt) {
-    return new PreparedStatement(this.db.prepare(stmt.sql));
-  }
-  schemaInstructions(tableName) {
-    const columnData = this.tableData(tableName);
-    const indexData = this.indexData(tableName);
-    return SqliteSchema.createInstructions(columnData, indexData);
-  }
-  export() {
-    return this.db.serialize();
-  }
-};
-function connect(db) {
-  return new BetterSqlite3Driver(db);
-}
-export {
-  BetterSqlite3Driver,
-  connect
-};