rado 0.3.0 → 0.3.2

package/dist/define/Cursor.d.ts

@@ -0,0 +1,85 @@
+import { Driver } from '../lib/Driver';
+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>;
+    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>;
+    }
+}

package/dist/define/Cursor.js

@@ -0,0 +1,256 @@
+// src/define/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");
+  }
+  on(driver) {
+    return driver.executeQuery(this.query());
+  }
+  toJSON() {
+    return this.query();
+  }
+};
+function addWhere(query, where) {
+  const conditions = where.slice();
+  if (query.where)
+    conditions.push(query.where);
+  return {
+    ...query,
+    where: Expr.and(...conditions).expr
+  };
+}
+((Cursor2) => {
+  class Delete extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    where(...where) {
+      return new Delete(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new Delete({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Delete({ ...this.query(), offset });
+    }
+  }
+  Cursor2.Delete = Delete;
+  class Update extends Cursor2 {
+    query() {
+      return super.query();
+    }
+    set(set) {
+      return new Update({ ...this.query(), set });
+    }
+    where(...where) {
+      return new Update(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new Update({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new Update({ ...this.query(), offset });
+    }
+  }
+  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 CreateTable extends Cursor2 {
+    constructor(table) {
+      super(Schema.create(table));
+      this.table = table;
+    }
+  }
+  Cursor2.CreateTable = CreateTable;
+  class Batch extends Cursor2 {
+    constructor(queries) {
+      super(Query.Batch({ queries }));
+      this.queries = queries;
+    }
+  }
+  Cursor2.Batch = Batch;
+  class SelectMultiple extends Cursor2 {
+    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(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new SelectMultiple({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new SelectMultiple({ ...this.query(), offset });
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectMultiple = SelectMultiple;
+  class SelectSingle extends Cursor2 {
+    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(addWhere(this.query(), where));
+    }
+    take(limit) {
+      return new SelectSingle({ ...this.query(), limit });
+    }
+    skip(offset) {
+      return new SelectSingle({ ...this.query(), offset });
+    }
+    all() {
+      return new SelectMultiple({ ...this.query(), singleResult: false });
+    }
+    toExpr() {
+      return new Expr(ExprData.Query(this.query()));
+    }
+  }
+  Cursor2.SelectSingle = SelectSingle;
+})(Cursor || (Cursor = {}));
+export {
+  Cursor
+};

package/dist/define/Schema.js

@@ -94,15 +94,20 @@ var Schema;
       return recreateTable(schema2, new Set(added));
     }
     const meta = schema2.meta();
+    const schemaIndexes = new Map(
+      Object.values(meta.indexes).map((index) => [index.name, index])
+    );
     const indexNames = /* @__PURE__ */ new Set([
       ...Object.keys(local.indexes),
-      ...Object.keys(meta.indexes)
+      ...schemaIndexes.keys()
     ]);
     for (const indexName of indexNames) {
       const localInstruction = local.indexes[indexName];
-      const schemaIndex = meta.indexes[indexName];
+      const schemaIndex = schemaIndexes.get(indexName);
       if (!localInstruction) {
-        res.push(new QueryData.CreateIndex({ table: schema2, index: schemaIndex }));
+        res.push(
+          new QueryData.CreateIndex({ table: schema2, index: schemaIndex })
+        );
         if (verbose)
           console.log(`Adding index ${indexName}`);
       } else if (!schemaIndex) {

package/dist/define/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/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> | (() => 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,68 @@
+// 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,
+      get references() {
+        return ExprData.create(typeof column2 === "function" ? column2() : 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,85 @@
+import { Driver } from './Driver';
+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>;
+    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>;
+    }
+}