rado 0.1.60 → 0.1.62

package/dist/Table.js

@@ -0,0 +1,104 @@
+// src/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);
+      }
+    });
+  }
+  insertOne(record) {
+    return new Cursor.Batch([
+      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);
+  }
+  createTable() {
+    return new Cursor.Create(this.schema());
+  }
+  as(alias) {
+    return new Table({ ...this.schema(), alias });
+  }
+  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]) => {
+      return [
+        key,
+        { name: key, on: index.on.map(ExprData.create), where: index.where?.expr }
+      ];
+    })
+  );
+  return new Table({
+    ...schema,
+    indexes
+  });
+}
+export {
+  Table,
+  table
+};

package/dist/Target.d.ts

@@ -0,0 +1,30 @@
+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/Target.js

@@ -0,0 +1,37 @@
+// src/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/Update.d.ts

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

package/dist/define/Column.d.ts

@@ -1,58 +1,58 @@
-import { EV, Expr, ExprData } from './Expr';
-export declare enum ColumnType {
-    String = "String",
-    Integer = "Integer",
-    Number = "Number",
-    Boolean = "Boolean",
-    Json = "Json"
-}
-interface PartialColumnData {
-    type: ColumnType;
-    name?: string;
-    nullable?: boolean;
-    defaultValue?: ExprData | (() => ExprData);
-    autoIncrement?: boolean;
-    primaryKey?: boolean;
-    unique?: boolean;
-    references?: () => ExprData;
-}
-export interface ColumnData extends PartialColumnData {
-    type: ColumnType;
-    name: string;
-}
-export declare class Column<T> {
-    data: PartialColumnData;
-    constructor(data: PartialColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): Column<Column.IsOptional<T>>;
-    primaryKey<K extends string>(create?: () => EV<T>): Column<Column.IsPrimary<T, K>>;
-    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
-    unique(): Column<T>;
-    defaultValue(create: () => EV<T>): Column<Column.IsOptional<T>>;
-    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
-}
-export type PrimaryKey<T, K> = string extends K ? T : T & {
-    [Column.isPrimary]: K;
-};
-export declare namespace Column {
-    const isOptional: unique symbol;
-    type IsOptional<T> = {
-        [isOptional]: true;
-        __t: T;
-    };
-    const isPrimary: unique symbol;
-    type IsPrimary<T, K> = {
-        [isPrimary]: K;
-        __t: T;
-    };
-}
-export declare const column: {
-    string<T extends string = string>(): Column<T>;
-    integer<T_1 extends number = number>(): Column<T_1>;
-    number<T_2 extends number = number>(): Column<T_2>;
-    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
-    object<T_4 extends object = object>(): Column<T_4>;
-    array<T_5 = any>(): Column<T_5[]>;
-};
-export {};
+import { EV, Expr, ExprData } from './Expr';
+export declare enum ColumnType {
+    String = "String",
+    Integer = "Integer",
+    Number = "Number",
+    Boolean = "Boolean",
+    Json = "Json"
+}
+interface PartialColumnData {
+    type: ColumnType;
+    name?: string;
+    nullable?: boolean;
+    defaultValue?: ExprData | (() => ExprData);
+    autoIncrement?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    references?: () => ExprData;
+}
+export interface ColumnData extends PartialColumnData {
+    type: ColumnType;
+    name: string;
+}
+export declare class Column<T> {
+    data: PartialColumnData;
+    constructor(data: PartialColumnData);
+    name(name: string): Column<T>;
+    nullable(): Column<T | null>;
+    autoIncrement(): Column<Column.IsOptional<T>>;
+    primaryKey<K extends string>(create?: () => EV<T>): Column<Column.IsPrimary<T, K>>;
+    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
+    unique(): Column<T>;
+    defaultValue(create: () => EV<T>): Column<Column.IsOptional<T>>;
+    defaultValue(value: EV<T>): Column<Column.IsOptional<T>>;
+}
+export type PrimaryKey<T, K> = string extends K ? T : T & {
+    [Column.isPrimary]: K;
+};
+export declare namespace Column {
+    const isOptional: unique symbol;
+    type IsOptional<T> = {
+        [isOptional]: true;
+        __t: T;
+    };
+    const isPrimary: unique symbol;
+    type IsPrimary<T, K> = {
+        [isPrimary]: K;
+        __t: T;
+    };
+}
+export declare const column: {
+    string<T extends string = string>(): Column<T>;
+    integer<T_1 extends number = number>(): Column<T_1>;
+    number<T_2 extends number = number>(): Column<T_2>;
+    boolean<T_3 extends boolean = boolean>(): Column<T_3>;
+    object<T_4 extends object = object>(): Column<T_4>;
+    array<T_5 = any>(): Column<T_5[]>;
+};
+export {};

package/dist/define/Cursor.d.ts

@@ -1,87 +1,87 @@
-import { Driver } from '../lib/Driver';
-import { CompileOptions } from '../lib/Formatter';
-import { EV, Expr } from './Expr';
-import { OrderBy } from './OrderBy';
-import { Query } from './Query';
-import { Schema } from './Schema';
-import { Selection } from './Selection';
-import { Table } from './Table';
-import { Update as UpdateSet } from './Update';
-export declare class Cursor<T> {
-    [Selection.__cursorType](): T;
-    constructor(query: Query<T>);
-    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
-    query(): Query<T>;
-    on(driver: Driver.Sync): T;
-    on(driver: Driver.Async): Promise<T>;
-    compile(driver: Driver, options?: CompileOptions): import("..").Statement;
-    toJSON(): Query<T>;
-}
-export declare namespace Cursor {
-    class Delete extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Delete;
-        where(...where: Array<EV<boolean>>): Delete;
-        take(limit: number | undefined): Delete;
-        skip(offset: number | undefined): Delete;
-    }
-    class Update<T> extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Update;
-        set(set: UpdateSet<T>): Update<T>;
-        where(...where: Array<EV<boolean>>): Update<T>;
-        take(limit: number | undefined): Update<T>;
-        skip(offset: number | undefined): Update<T>;
-    }
-    class InsertValuesReturning<T> extends Cursor<T> {
-    }
-    class InsertValues extends Cursor<{
-        rowsAffected: number;
-    }> {
-        query(): Query.Insert;
-        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
-    }
-    class Insert<T> {
-        protected into: Schema;
-        constructor(into: Schema);
-        values(...data: Array<Table.Insert<T>>): InsertValues;
-    }
-    class CreateTable extends Cursor<void> {
-        protected table: Schema;
-        constructor(table: Schema);
-    }
-    class Batch<T = void> extends Cursor<T> {
-        protected queries: Array<Query>;
-        constructor(queries: Array<Query>);
-    }
-    class SelectMultiple<T> extends Cursor<Array<T>> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
-        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
-        count(): SelectSingle<number>;
-        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
-        first(): SelectSingle<T | undefined>;
-        sure(): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
-        take(limit: number | undefined): SelectMultiple<T>;
-        skip(offset: number | undefined): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-    class SelectSingle<T> extends Cursor<T> {
-        query(): Query.Select;
-        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
-        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
-        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
-        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
-        where(...where: Array<EV<boolean>>): SelectSingle<T>;
-        take(limit: number | undefined): SelectSingle<T>;
-        skip(offset: number | undefined): SelectSingle<T>;
-        all(): SelectMultiple<T>;
-        toExpr(): Expr<T>;
-    }
-}
+import { Driver } from '../lib/Driver';
+import { CompileOptions } from '../lib/Formatter';
+import { EV, Expr } from './Expr';
+import { OrderBy } from './OrderBy';
+import { Query } from './Query';
+import { Schema } from './Schema';
+import { Selection } from './Selection';
+import { Table } from './Table';
+import { Update as UpdateSet } from './Update';
+export declare class Cursor<T> {
+    [Selection.__cursorType](): T;
+    constructor(query: Query<T>);
+    static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
+    query(): Query<T>;
+    on(driver: Driver.Sync): T;
+    on(driver: Driver.Async): Promise<T>;
+    compile(driver: Driver, options?: CompileOptions): import("..").Statement;
+    toJSON(): Query<T>;
+}
+export declare namespace Cursor {
+    class Delete extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Delete;
+        where(...where: Array<EV<boolean>>): Delete;
+        take(limit: number | undefined): Delete;
+        skip(offset: number | undefined): Delete;
+    }
+    class Update<T> extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Update;
+        set(set: UpdateSet<T>): Update<T>;
+        where(...where: Array<EV<boolean>>): Update<T>;
+        take(limit: number | undefined): Update<T>;
+        skip(offset: number | undefined): Update<T>;
+    }
+    class InsertValuesReturning<T> extends Cursor<T> {
+    }
+    class InsertValues extends Cursor<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Insert;
+        returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
+    }
+    class Insert<T> {
+        protected into: Schema;
+        constructor(into: Schema);
+        values(...data: Array<Table.Insert<T>>): InsertValues;
+    }
+    class CreateTable extends Cursor<void> {
+        protected table: Schema;
+        constructor(table: Schema);
+    }
+    class Batch<T = void> extends Cursor<T> {
+        protected queries: Array<Query>;
+        constructor(queries: Array<Query>);
+    }
+    class SelectMultiple<T> extends Cursor<Array<T>> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectMultiple<T>;
+        select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
+        count(): SelectSingle<number>;
+        orderBy(...orderBy: Array<Expr<any> | OrderBy>): SelectMultiple<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectMultiple<T>;
+        first(): SelectSingle<T | undefined>;
+        sure(): SelectSingle<T>;
+        where(...where: Array<EV<boolean>>): SelectMultiple<T>;
+        take(limit: number | undefined): SelectMultiple<T>;
+        skip(offset: number | undefined): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+    class SelectSingle<T> extends Cursor<T> {
+        query(): Query.Select;
+        leftJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        innerJoin<C>(that: Table<C>, ...on: Array<EV<boolean>>): SelectSingle<T>;
+        select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
+        orderBy(...orderBy: Array<OrderBy>): SelectSingle<T>;
+        groupBy(...groupBy: Array<Expr<any>>): SelectSingle<T>;
+        where(...where: Array<EV<boolean>>): SelectSingle<T>;
+        take(limit: number | undefined): SelectSingle<T>;
+        skip(offset: number | undefined): SelectSingle<T>;
+        all(): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+}