rado 0.3.1 → 0.3.2

package/dist/lib/Formatter.d.ts

@@ -62,7 +62,7 @@ export declare abstract class Formatter implements Sanitizer {
     formatBatch(ctx: FormatContext, { queries }: QueryData.Batch): Statement;
     formatRaw(ctx: FormatContext, { strings, params }: QueryData.Raw): Statement;
     formatColumn(ctx: FormatContext, column: ColumnData): Statement;
-    formatConstraintReference(ctx: FormatContext, reference: ExprData): Statement;
+    formatConstraintReference(ctx: FormatContext, { references, onDelete, onUpdate }: ColumnData): Statement;
     formatType(ctx: FormatContext, type: ColumnType): Statement;
     formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
     formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;

package/dist/lib/Formatter.js

@@ -1,4 +1,4 @@
-import { ColumnType } from "../define/Column.js";
+import { Action, ColumnType } from "../define/Column.js";
 import { BinOpType, Expr, ExprData, ExprType, UnOpType } from "../define/Expr.js";
 import { OrderDirection } from "../define/OrderBy.js";
 import { ParamType } from "../define/Param.js";
@@ -36,6 +36,13 @@ const unions = {
   [QueryData.UnionOperation.Intersect]: "INTERSECT",
   [QueryData.UnionOperation.Except]: "EXCEPT"
 };
+const actions = {
+  [Action.NoAction]: "NO ACTION",
+  [Action.Restrict]: "RESTRICT",
+  [Action.Cascade]: "CASCADE",
+  [Action.SetNull]: "SET NULL",
+  [Action.SetDefault]: "SET DEFAULT"
+};
 function formatAsResultObject(stmt, mkSubject) {
   stmt.raw("json_object('result', ");
   mkSubject();
@@ -318,15 +325,23 @@ class Formatter {
       }
     }
     if (column.references)
-      this.formatConstraintReference(ctx, column.references());
+      this.formatConstraintReference(ctx, column);
     return stmt;
   }
-  formatConstraintReference(ctx, reference) {
+  formatConstraintReference(ctx, { references, onDelete, onUpdate }) {
     const { stmt } = ctx;
+    if (!references)
+      return stmt;
+    const reference = references();
     if (reference.type !== ExprType.Field || reference.expr.type !== ExprType.Row)
       throw new Error("not supported");
     const from = reference.expr.target;
-    return stmt.add("REFERENCES").addIdentifier(Target.source(from).name).openParenthesis().identifier(reference.field).closeParenthesis();
+    stmt.add("REFERENCES").addIdentifier(Target.source(from).name).openParenthesis().identifier(reference.field).closeParenthesis();
+    if (onDelete && actions[onDelete])
+      stmt.add("ON DELETE").add(actions[onDelete]);
+    if (onUpdate && actions[onUpdate])
+      stmt.add("ON UPDATE").add(actions[onUpdate]);
+    return stmt;
   }
   formatType(ctx, type) {
     const { stmt } = ctx;

package/dist/lib/Functions.d.ts

@@ -0,0 +1,5 @@
+import { Expr } from './Expr';
+export declare const Functions: Functions;
+export type Functions = {
+    [key: string]: (...args: Array<any>) => Expr<any>;
+};

package/dist/lib/Functions.js

@@ -0,0 +1,11 @@
+// src/lib/Functions.ts
+import { Expr, ExprData } from "./Expr.js";
+function get(_, method) {
+  return (...args) => {
+    return new Expr(ExprData.Call(method, args.map(ExprData.create)));
+  };
+}
+var Functions = new Proxy({}, { get });
+export {
+  Functions
+};

package/dist/lib/Id.d.ts

@@ -0,0 +1,3 @@
+export type Id<T> = T extends {
+    id: any;
+} ? T['id'] : never;

package/dist/lib/Index.d.ts

@@ -0,0 +1,17 @@
+import { Expr, ExprData } from './Expr';
+interface PartialIndexData {
+    on: Array<ExprData>;
+    unique?: boolean;
+    where?: ExprData;
+}
+export interface IndexData extends PartialIndexData {
+    name: string;
+}
+export declare class Index {
+    data: PartialIndexData;
+    constructor(data: PartialIndexData);
+    unique(): Index;
+    where(where: Expr<boolean>): Index;
+}
+export declare function index(...on: Array<Expr<any>>): Index;
+export {};

package/dist/lib/Index.js

@@ -0,0 +1,20 @@
+// src/lib/Index.ts
+import { ExprData } from "./Expr.js";
+var Index = class {
+  constructor(data) {
+    this.data = data;
+  }
+  unique() {
+    return new Index({ ...this.data, unique: true });
+  }
+  where(where) {
+    return new Index({ ...this.data, where: ExprData.create(where) });
+  }
+};
+function index(...on) {
+  return new Index({ on: on.map(ExprData.create) });
+}
+export {
+  Index,
+  index
+};

package/dist/lib/Ops.d.ts

@@ -0,0 +1,7 @@
+import { Cursor } from './Cursor';
+import { Table } from './Table';
+export declare function from<Row>(source: Table<Row> | Cursor.SelectMultiple<Row>): Cursor.SelectMultiple<Row>;
+export declare function update<Row>(table: Table<Row>): Cursor.Update<Row>;
+export declare function insertInto<Row>(table: Table<Row>): Cursor.Insert<Row>;
+export declare function deleteFrom<Row>(table: Table<Row>): Cursor.Delete;
+export declare function create(...tables: Array<Table<any>>): Cursor.Batch;

package/dist/lib/Ops.js

@@ -0,0 +1,36 @@
+// src/lib/Ops.ts
+import { Cursor } from "./Cursor.js";
+import { ExprData } from "./Expr.js";
+import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
+import { Target } from "./Target.js";
+function from(source) {
+  const target = "schema" in source ? Target.Table(source.schema()) : Target.Query(source.query());
+  return new Cursor.SelectMultiple(
+    Query.Select({
+      from: target,
+      selection: ExprData.Row(target)
+    })
+  );
+}
+function update(table) {
+  return new Cursor.Update(Query.Update({ table: table.schema() }));
+}
+function insertInto(table) {
+  return new Cursor.Insert(table.schema());
+}
+function deleteFrom(table) {
+  return new Cursor.Delete(Query.Delete({ table: table.schema() }));
+}
+function create(...tables) {
+  return new Cursor.Batch(
+    tables.flatMap((table) => Schema.create(table.schema()).queries)
+  );
+}
+export {
+  create,
+  deleteFrom,
+  from,
+  insertInto,
+  update
+};

package/dist/lib/OrderBy.d.ts

@@ -0,0 +1,9 @@
+import { ExprData } from './Expr';
+export declare enum OrderDirection {
+    Asc = "Asc",
+    Desc = "Desc"
+}
+export type OrderBy = {
+    expr: ExprData;
+    order: OrderDirection;
+};

package/dist/lib/OrderBy.js

@@ -0,0 +1,9 @@
+// src/lib/OrderBy.ts
+var OrderDirection = /* @__PURE__ */ ((OrderDirection2) => {
+  OrderDirection2["Asc"] = "Asc";
+  OrderDirection2["Desc"] = "Desc";
+  return OrderDirection2;
+})(OrderDirection || {});
+export {
+  OrderDirection
+};

package/dist/lib/Param.d.ts

@@ -0,0 +1,20 @@
+import { Expr } from './Expr';
+export declare enum ParamType {
+    Value = "Value",
+    Named = "Named"
+}
+export type ParamData = {
+    type: ParamType.Value;
+    value: any;
+} | {
+    type: ParamType.Named;
+    name: string;
+};
+export declare const ParamData: {
+    Value(value: any): ParamData;
+    Named(name: string): ParamData;
+};
+export type Params<T> = {
+    [K in keyof T]: Expr<T[K]>;
+};
+export declare function createParams<T>(): Params<T>;

package/dist/lib/Param.js

@@ -0,0 +1,27 @@
+// src/lib/Param.ts
+import { Expr, ExprData } from "./Expr.js";
+var ParamType = /* @__PURE__ */ ((ParamType2) => {
+  ParamType2["Value"] = "Value";
+  ParamType2["Named"] = "Named";
+  return ParamType2;
+})(ParamType || {});
+var ParamData = {
+  Value(value) {
+    return { type: "Value" /* Value */, value };
+  },
+  Named(name) {
+    return { type: "Named" /* Named */, name };
+  }
+};
+function createParams() {
+  return new Proxy({}, {
+    get(target, prop) {
+      return new Expr(ExprData.Param(ParamData.Named(prop)));
+    }
+  });
+}
+export {
+  ParamData,
+  ParamType,
+  createParams
+};

package/dist/lib/Query.d.ts

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

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

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

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

@@ -0,0 +1,20 @@
+import type { Cursor } from './Cursor';
+import type { Expr } from './Expr';
+type SelectionBase = (() => any) | 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 as T[K] extends () => any ? never : K]: Infer<T[K]>;
+    } : T extends () => any ? never : 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

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

package/dist/lib/Table.d.ts

@@ -0,0 +1,62 @@
+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.CreateTable;
+    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 {};
+}