rado 0.1.60 → 0.1.62

package/dist/index.d.ts

@@ -1,21 +1,21 @@
-export * from './define/Column';
-export * from './define/Cursor';
-export * from './define/Expr';
-export * from './define/Fields';
-export * from './define/Functions';
-export * from './define/Id';
-export * from './define/Index';
-export * from './define/Ops';
-export * from './define/OrderBy';
-export * from './define/Param';
-export * from './define/Query';
-export * from './define/Schema';
-export * from './define/Selection';
-export * from './define/Table';
-export * from './define/Target';
-export * from './define/Update';
-export type { Driver } from './lib/Driver';
-export type { FormatContext, Formatter } from './lib/Formatter';
-export type { Sanitizer } from './lib/Sanitizer';
-export * from './lib/SqlError';
-export type { Statement } from './lib/Statement';
+export * from './define/Column';
+export * from './define/Cursor';
+export * from './define/Expr';
+export * from './define/Fields';
+export * from './define/Functions';
+export * from './define/Id';
+export * from './define/Index';
+export * from './define/Ops';
+export * from './define/OrderBy';
+export * from './define/Param';
+export * from './define/Query';
+export * from './define/Schema';
+export * from './define/Selection';
+export * from './define/Table';
+export * from './define/Target';
+export * from './define/Update';
+export type { Driver } from './lib/Driver';
+export type { FormatContext, Formatter } from './lib/Formatter';
+export type { Sanitizer } from './lib/Sanitizer';
+export * from './lib/SqlError';
+export type { Statement } from './lib/Statement';

package/dist/lib/Column.d.ts

@@ -0,0 +1,57 @@
+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;
+    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>(): Column<Column.IsPrimary<T, K>>;
+    references<X extends T>(column: Expr<X>): Column<X>;
+    unique(): Column<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/lib/Column.js

@@ -0,0 +1,63 @@
+// src/lib/Column.ts
+import { ExprData } from "./Expr.js";
+var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
+  ColumnType2["String"] = "String";
+  ColumnType2["Integer"] = "Integer";
+  ColumnType2["Number"] = "Number";
+  ColumnType2["Boolean"] = "Boolean";
+  ColumnType2["Json"] = "Json";
+  return ColumnType2;
+})(ColumnType || {});
+var Column = class {
+  constructor(data) {
+    this.data = data;
+  }
+  name(name) {
+    return new Column({ ...this.data, name });
+  }
+  nullable() {
+    return new Column({ ...this.data, nullable: true });
+  }
+  autoIncrement() {
+    return new Column({ ...this.data, autoIncrement: true });
+  }
+  primaryKey() {
+    return new Column({ ...this.data, primaryKey: true });
+  }
+  references(column2) {
+    return new Column({ ...this.data, references: ExprData.create(column2) });
+  }
+  unique() {
+    return new Column({ ...this.data, unique: true });
+  }
+  defaultValue(value) {
+    return new Column({ ...this.data, defaultValue: ExprData.create(value) });
+  }
+};
+((Column2) => {
+})(Column || (Column = {}));
+var column = {
+  string() {
+    return new Column({ type: "String" /* String */ });
+  },
+  integer() {
+    return new Column({ type: "Integer" /* Integer */ });
+  },
+  number() {
+    return new Column({ type: "Number" /* Number */ });
+  },
+  boolean() {
+    return new Column({ type: "Boolean" /* Boolean */ });
+  },
+  object() {
+    return new Column({ type: "Json" /* Json */ });
+  },
+  array() {
+    return new Column({ type: "Json" /* Json */ });
+  }
+};
+export {
+  Column,
+  ColumnType,
+  column
+};

package/dist/lib/Cursor.d.ts

@@ -0,0 +1,79 @@
+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>;
+    toJSON(): Query<T>;
+}
+export declare namespace Cursor {
+    class Limitable<T> extends Cursor<T> {
+        take(limit: number | undefined): Limitable<T>;
+        skip(offset: number | undefined): Limitable<T>;
+    }
+    class Filterable<T> extends Limitable<T> {
+        where(...where: Array<EV<boolean>>): Filterable<T>;
+    }
+    class Delete extends Filterable<{
+        rowsAffected: number;
+    }> {
+        query(): Query.Delete;
+    }
+    class Update<T> extends Filterable<{
+        rowsAffected: number;
+    }> {
+        query: () => Query.Update;
+        set(set: UpdateSet<T>): 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 Create 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 Filterable<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>;
+        toExpr(): Expr<T>;
+    }
+    class SelectSingle<T> extends Filterable<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>;
+        all(): SelectMultiple<T>;
+        toExpr(): Expr<T>;
+    }
+}

package/dist/lib/Cursor.js

@@ -0,0 +1,231 @@
+// src/lib/Cursor.ts
+import { Expr, ExprData } from "./Expr.js";
+import { Functions } from "./Functions.js";
+import { Query } from "./Query.js";
+import { Schema } from "./Schema.js";
+import { Selection } from "./Selection.js";
+import { Target } from "./Target.js";
+var Cursor = class {
+  [Selection.__cursorType]() {
+    throw "assert";
+  }
+  constructor(query) {
+    Object.defineProperty(this, "query", {
+      enumerable: false,
+      value: () => query
+    });
+  }
+  static all(strings, ...params) {
+    return new Cursor(Query.Raw({ expectedReturn: "rows", strings, params }));
+  }
+  query() {
+    throw new Error("Not implemented");
+  }
+  toJSON() {
+    return this.query();
+  }
+};
+((Cursor2) => {
+  class Limitable extends Cursor2 {
+    take(limit) {
+      return new Limitable({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Limitable({ ...this.query(), offset });
+    }
+  }
+  Cursor2.Limitable = Limitable;
+  class Filterable extends Limitable {
+    where(...where) {
+      const condition = Expr.and(...where);
+      const query = this.query();
+      return new Filterable({
+        ...query,
+        where: (query.where ? condition.and(new Expr(query.where)) : condition).expr
+      });
+    }
+  }
+  Cursor2.Filterable = Filterable;
+  class Delete extends Filterable {
+    query() {
+      return super.query();
+    }
+  }
+  Cursor2.Delete = Delete;
+  class Update extends Filterable {
+    set(set) {
+      return new Update({ ...this.query(), set });
+    }
+  }
+  Cursor2.Update = Update;
+  class InsertValuesReturning extends Cursor2 {
+  }
+  Cursor2.InsertValuesReturning = InsertValuesReturning;
+  class InsertValues extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    returning(selection) {
+      return new InsertValuesReturning(
+        Query.Insert({ ...this.query(), selection: ExprData.create(selection) })
+      );
+    }
+  }
+  Cursor2.InsertValues = InsertValues;
+  class Insert {
+    constructor(into) {
+      this.into = into;
+    }
+    values(...data) {
+      return new InsertValues(Query.Insert({ into: this.into, data }));
+    }
+  }
+  Cursor2.Insert = Insert;
+  class Create extends Cursor2 {
+    constructor(table) {
+      super(Schema.create(table));
+      this.table = table;
+    }
+  }
+  Cursor2.Create = Create;
+  class Batch extends Cursor2 {
+    constructor(queries) {
+      super(Query.Batch({ queries }));
+      this.queries = queries;
+    }
+  }
+  Cursor2.Batch = Batch;
+  class SelectMultiple extends Filterable {
+    query() {
+      return super.query();
+    }
+    leftJoin(that, ...on) {
+      const query = this.query();
+      return new SelectMultiple({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this.query();
+      return new SelectMultiple({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "inner",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    select(selection) {
+      return new SelectMultiple({
+        ...this.query(),
+        selection: ExprData.create(selection)
+      });
+    }
+    count() {
+      return new SelectSingle({
+        ...this.query(),
+        selection: Functions.count().expr,
+        singleResult: true
+      });
+    }
+    orderBy(...orderBy) {
+      return new SelectMultiple({
+        ...this.query(),
+        orderBy: orderBy.map((e) => {
+          return e instanceof Expr ? e.asc() : e;
+        })
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectMultiple({
+        ...this.query(),
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    first() {
+      return new SelectSingle({ ...this.query(), singleResult: true });
+    }
+    sure() {
+      return new SelectSingle({
+        ...this.query(),
+        singleResult: true,
+        validate: true
+      });
+    }
+    where(...where) {
+      return new SelectMultiple(super.where(...where).query());
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectMultiple = SelectMultiple;
+  class SelectSingle extends Filterable {
+    query() {
+      return super.query();
+    }
+    leftJoin(that, ...on) {
+      const query = this.query();
+      return new SelectSingle({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "left",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    innerJoin(that, ...on) {
+      const query = this.query();
+      return new SelectSingle({
+        ...query,
+        from: Target.Join(
+          query.from,
+          Target.Table(that.schema()),
+          "inner",
+          Expr.and(...on).expr
+        )
+      });
+    }
+    select(selection) {
+      return new SelectSingle({
+        ...this.query(),
+        selection: ExprData.create(selection)
+      });
+    }
+    orderBy(...orderBy) {
+      return new SelectSingle({
+        ...this.query(),
+        orderBy
+      });
+    }
+    groupBy(...groupBy) {
+      return new SelectSingle({
+        ...this.query(),
+        groupBy: groupBy.map(ExprData.create)
+      });
+    }
+    where(...where) {
+      return new SelectSingle(super.where(...where).query());
+    }
+    all() {
+      return new SelectMultiple({ ...this.query(), singleResult: false });
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectSingle = SelectSingle;
+})(Cursor || (Cursor = {}));
+export {
+  Cursor
+};