rado 0.1.62 → 0.1.63

package/dist/Table.js

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

@@ -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/Target.js

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

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

package/dist/lib/Column.d.ts

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

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

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

@@ -1,231 +0,0 @@
-// 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
-};