rado 0.2.14 → 0.2.16

package/dist/define/Column.d.ts

@@ -1,5 +1,7 @@
 import { EV, Expr, ExprData } from './Expr';
 import { Fields } from './Fields';
+declare const DATA: unique symbol;
+declare const TYPE: unique symbol;
 export declare enum ColumnType {
     String = "String",
     Integer = "Integer",
@@ -23,22 +25,22 @@ export interface ColumnData extends PartialColumnData {
     name: string;
 }
 export interface Column<T> {
-    [Column.type]: T;
-    [Column.data]: PartialColumnData;
+    [TYPE]: T;
+    [DATA]: PartialColumnData;
 }
 export declare namespace Column {
-    const data: unique symbol;
-    const type: unique symbol;
-    const isOptional: unique symbol;
-    const isNullable: unique symbol;
-    const isPrimary: unique symbol;
+    const Data: typeof DATA;
+    const Type: typeof TYPE;
+    const IsOptional: unique symbol;
+    const IsNullable: unique symbol;
+    const IsPrimary: unique symbol;
 }
 interface ValueColumn<T> extends Expr<T> {
     <X extends T = T>(): ValueColumn<T extends null ? X | null : X>;
 }
 declare class ValueColumn<T> implements Column<T> {
-    [Column.type]: T;
-    [Column.data]: PartialColumnData;
+    [TYPE]: T;
+    [DATA]: PartialColumnData;
     constructor(data: PartialColumnData);
     get nullable(): ValueColumn<T | null>;
     get unique(): ValueColumn<T>;
@@ -48,34 +50,34 @@ declare class ValueColumn<T> implements Column<T> {
     defaultValue(value: DefaultValue<T>): OptionalColumn<T>;
 }
 export declare class OptionalColumn<T> extends ValueColumn<T> {
-    [Column.isOptional]: true;
+    [Column.IsOptional]: true;
 }
 export declare class PrimaryColumn<T, K> extends ValueColumn<PrimaryKey<T, K>> {
-    [Column.isPrimary]: K;
+    [Column.IsPrimary]: K;
 }
 interface ObjectColumn<T> {
     <X extends T = T>(): Column<T extends null ? X | null : X> & Fields<X>;
 }
 declare class ObjectColumn<T> implements Column<T> {
-    [Column.type]: T;
-    [Column.data]: PartialColumnData;
+    [TYPE]: T;
+    [DATA]: PartialColumnData;
     constructor(data: PartialColumnData);
     get nullable(): ObjectColumn<T | null>;
     get unique(): ObjectColumn<T>;
     defaultValue<X extends T = T>(value: DefaultValue<X>): Column<X> & Fields<X>;
 }
 export declare class OptionalObjectColumn<T> extends ObjectColumn<T> {
-    [Column.isOptional]: true;
+    [Column.IsOptional]: true;
 }
 export type PrimaryKey<T, K> = string extends K ? T : T & {
-    [Column.isPrimary]: K;
+    [Column.IsPrimary]: K;
 };
 type DefaultValue<T> = EV<T> | (() => EV<T>);
 interface UnTyped {
     (name: string): UnTyped;
 }
 declare class UnTyped {
-    [Column.data]: PartialColumnData;
+    [DATA]: PartialColumnData;
     constructor(data?: PartialColumnData);
     get nullable(): NullableUnTyped;
     get unique(): UnTyped;
@@ -88,7 +90,7 @@ declare class UnTyped {
     get array(): ValueColumn<any[]>;
 }
 declare class NullableUnTyped {
-    [Column.data]: PartialColumnData;
+    [DATA]: PartialColumnData;
     get unique(): UnTyped;
     get string(): ValueColumn<string | null>;
     get integer(): ValueColumn<number | null>;

package/dist/define/Column.js

@@ -1,6 +1,8 @@
 // src/define/Column.ts
 import { callable } from "../util/Callable.js";
 import { Expr, ExprData } from "./Expr.js";
+var DATA = Symbol("DATA");
+var TYPE = Symbol("tYPE");
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
   ColumnType2["Integer"] = "Integer";
@@ -11,40 +13,39 @@ var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
 })(ColumnType || {});
 var Column;
 ((Column2) => {
-  Column2.data = Symbol("columnData");
-  Column2.type = Symbol("columnType");
+  Column2.Data = DATA;
+  Column2.Type = TYPE;
 })(Column || (Column = {}));
 var ValueColumn = class {
-  [Column.type];
-  [Column.data];
+  [(TYPE, DATA)];
   constructor(data) {
-    this[Column.data] = data;
+    this[DATA] = data;
     return callable(this, (defaultValue) => {
       return new ValueColumn({
-        ...this[Column.data],
+        ...this[DATA],
         defaultValue: createDefaultValue(defaultValue)
       });
     });
   }
   get nullable() {
-    return new ValueColumn({ ...this[Column.data], nullable: true });
+    return new ValueColumn({ ...this[DATA], nullable: true });
   }
   get unique() {
-    return new ValueColumn({ ...this[Column.data], unique: true });
+    return new ValueColumn({ ...this[DATA], unique: true });
   }
   get autoIncrement() {
-    return new OptionalColumn({ ...this[Column.data], autoIncrement: true });
+    return new OptionalColumn({ ...this[DATA], autoIncrement: true });
   }
   primaryKey(create) {
     return new PrimaryColumn({
-      ...this[Column.data],
+      ...this[DATA],
       primaryKey: true,
-      defaultValue: create ? () => ExprData.create(create()) : this[Column.data].defaultValue
+      defaultValue: create ? () => ExprData.create(create()) : this[DATA].defaultValue
     });
   }
   references(column2) {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       references() {
         return ExprData.create(Expr.isExpr(column2) ? column2 : column2());
       }
@@ -52,7 +53,7 @@ var ValueColumn = class {
   }
   defaultValue(value) {
     return new OptionalColumn({
-      ...this[Column.data],
+      ...this[DATA],
       defaultValue: createDefaultValue(value)
     });
   }
@@ -61,87 +62,86 @@ function createDefaultValue(value) {
   return typeof value === "function" && !Expr.isExpr(value) ? () => ExprData.create(value()) : ExprData.create(value);
 }
 var OptionalColumn = class extends ValueColumn {
-  [Column.isOptional];
+  [Column.IsOptional];
 };
 var PrimaryColumn = class extends ValueColumn {
-  [Column.isPrimary];
+  [Column.IsPrimary];
 };
 var ObjectColumn = class {
-  [Column.type];
-  [Column.data];
+  [(TYPE, DATA)];
   constructor(data) {
-    this[Column.data] = data;
+    this[DATA] = data;
     return callable(this, () => this);
   }
   get nullable() {
-    return new ObjectColumn({ ...this[Column.data], nullable: true });
+    return new ObjectColumn({ ...this[DATA], nullable: true });
   }
   get unique() {
-    return new ObjectColumn({ ...this[Column.data], unique: true });
+    return new ObjectColumn({ ...this[DATA], unique: true });
   }
   defaultValue(value) {
     return new OptionalObjectColumn({
-      ...this[Column.data],
+      ...this[DATA],
       defaultValue: createDefaultValue(value)
     });
   }
 };
 var OptionalObjectColumn = class extends ObjectColumn {
-  [Column.isOptional];
+  [Column.IsOptional];
 };
 var UnTyped = class {
-  [Column.data];
+  [DATA];
   constructor(data = {}) {
-    this[Column.data] = data;
+    this[DATA] = data;
     return callable(this, (name) => {
       return new ValueColumn({ ...data, name });
     });
   }
   get nullable() {
-    return new UnTyped({ ...this[Column.data], nullable: true });
+    return new UnTyped({ ...this[DATA], nullable: true });
   }
   get unique() {
-    return new UnTyped({ ...this[Column.data], unique: true });
+    return new UnTyped({ ...this[DATA], unique: true });
   }
   get string() {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "String" /* String */
     });
   }
   get integer() {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "Integer" /* Integer */
     });
   }
   get number() {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "Number" /* Number */
     });
   }
   get boolean() {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "Boolean" /* Boolean */
     });
   }
   get json() {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "Json" /* Json */
     });
   }
   get object() {
     return new ObjectColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "Json" /* Json */
     });
   }
   get array() {
     return new ValueColumn({
-      ...this[Column.data],
+      ...this[DATA],
       type: "Json" /* Json */
     });
   }

package/dist/define/Cursor.d.ts

@@ -5,11 +5,13 @@ import { OrderBy } from './OrderBy';
 import { Query } from './Query';
 import { Selection } from './Selection';
 import { Table, TableData } from './Table';
+declare const QUERY: unique symbol;
 export declare class Cursor<T> {
-    [Selection.__cursorType](): T;
+    [Selection.CursorType]: () => T;
+    [QUERY]: Query<T>;
+    static Query: typeof QUERY;
     constructor(query: Query<T>);
     static all(strings: TemplateStringsArray, ...params: Array<any>): Cursor<any>;
-    query(): Query<T>;
     next<T>(cursor: Cursor<T>): Cursor<T>;
     on(driver: Driver.Sync): T;
     on(driver: Driver.Async): Promise<T>;
@@ -28,7 +30,7 @@ export declare namespace Cursor {
     class Update<Definition> extends Cursor<{
         rowsAffected: number;
     }> {
-        query(): Query.Update;
+        [QUERY]: Query.Update;
         set(set: Table.Update<Definition>): Update<Definition>;
         where(...where: Array<EV<boolean>>): Update<Definition>;
         take(limit: number | undefined): Update<Definition>;
@@ -39,7 +41,8 @@ export declare namespace Cursor {
     class Inserted extends Cursor<{
         rowsAffected: number;
     }> {
-        query(): Query.Insert;
+        [QUERY]: Query.Insert;
+        constructor(query: Query.Insert);
         returning<X extends Selection>(selection: X): InsertValuesReturning<Selection.Infer<X>>;
     }
     class Insert<Definition> {
@@ -54,12 +57,13 @@ export declare namespace Cursor {
     }
     class Batch<T = void> extends Cursor<T> {
         protected queries: Array<Query>;
-        query(): Query.Batch;
+        [QUERY]: Query.Batch;
         constructor(queries: Array<Query>);
         next<T>(cursor: Cursor<T>): Cursor<T>;
     }
     class SelectMultiple<Row> extends Cursor<Array<Row>> {
-        query(): Query.Select;
+        [QUERY]: Query.Select;
+        constructor(query: Query.Select);
         leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
         innerJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectMultiple<Row>;
         select<X extends Selection>(selection: X): SelectMultiple<Selection.Infer<X>>;
@@ -71,9 +75,11 @@ export declare namespace Cursor {
         where(...where: Array<EV<boolean>>): SelectMultiple<Row>;
         take(limit: number | undefined): SelectMultiple<Row>;
         skip(offset: number | undefined): SelectMultiple<Row>;
+        [Expr.ToExpr](): Expr<Row>;
     }
     class TableSelect<Definition> extends SelectMultiple<Table.Select<Definition>> {
         protected table: TableData;
+        [QUERY]: Query.Select;
         constructor(table: TableData, conditions?: Array<EV<boolean>>);
         as(alias: string): Table<Definition>;
         create(): CreateTable;
@@ -85,7 +91,8 @@ export declare namespace Cursor {
         get(name: string): Expr<any>;
     }
     class SelectSingle<Row> extends Cursor<Row> {
-        query(): Query.Select;
+        [QUERY]: Query.Select;
+        constructor(query: Query.Select);
         leftJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
         innerJoin<C>(that: Table<C> | TableSelect<C>, ...on: Array<EV<boolean>>): SelectSingle<Row>;
         select<X extends Selection>(selection: X): SelectSingle<Selection.Infer<X>>;
@@ -95,5 +102,7 @@ export declare namespace Cursor {
         take(limit: number | undefined): SelectSingle<Row>;
         skip(offset: number | undefined): SelectSingle<Row>;
         all(): SelectMultiple<Row>;
+        [Expr.ToExpr](): Expr<Row>;
     }
 }
+export {};