rado 0.2.5 → 0.2.7

package/README.md

@@ -3,9 +3,7 @@
 Fully typed, lightweight TypeScript query builder.
 Currently focused on SQLite.
 
-```
-npm install rado
-```
+<pre>npm install <a href="https://www.npmjs.com/package/rado">rado</a></pre>
 
 - Definition via TypeScript types
 - Composable queries
@@ -70,8 +68,8 @@ User().select({
 })
 ```
 
-You can call the `posts` helper method defined in the example schema to achieve
-the same:
+You can call the `posts` helper method defined in the example schema below
+to achieve the same:
 
 ```ts
 User().select({
@@ -109,9 +107,12 @@ User({id: 1}).innerJoin(Post({userId: User.id})).select({
 Create expressions to select complex values:
 
 ```ts
+import {iif} from 'rado/sqlite'
 Person().select({
   name: Person.firstName.concat(' ').concat(Person.lastName),
-  isMario: Person.firstName.is('Mario')
+  isMario: Person.firstName.is('Mario'),
+  isActor: Person.id.isIn(Actor().select(Actor.personId)),
+  email: iif(Person.email.isNotNull(), Person.email, 'its.me@mario')
 })
 ```
 
@@ -171,8 +172,8 @@ import {table, column} from 'rado'
 const User = table({
   // Pass a definition under a key with the actual name of the table in database
   user: class {
-    id = column.integer().primaryKey()
-    username = column.string()
+    id = column.integer.primaryKey()
+    username = column.string
 
     // Define helper methods directly on the model
     posts() {
@@ -183,9 +184,9 @@ const User = table({
 
 const Post = table({
   post: class {
-    id = column.integer().primaryKey()
-    userId = column.integer().references(() => User.id)
-    content = column.string()
+    id = column.integer.primaryKey()
+    userId = column.integer.references(() => User.id)
+    content = column.string
 
     author() {
       return User({id: this.userId}).sure()
@@ -199,15 +200,15 @@ const Post = table({
 
 const Tag = table({
   tag: class {
-    id = column.integer().primaryKey()
-    name = column.string()
+    id = column.integer.primaryKey()
+    name = column.string
   }
 })
 
 const PostTags = table({
   post_tag: class {
-    postId = column.integer().references(() => Post.id)
-    tagId = column.integer().references(() => Tag.id)
+    postId = column.integer.references(() => Post.id)
+    tagId = column.integer.references(() => Tag.id)
   }
 })
 ```
@@ -257,7 +258,7 @@ for await (const row of db.iterate(allPosts)) {
 #### Transactions
 
 Run transactions within the `transaction` method which will isolate a connection
-for you and can optionally return a result:
+and can optionally return a result:
 
 ```ts
 const firstUserId = db.transaction(tx => {

package/dist/define/Column.d.ts

@@ -1,4 +1,6 @@
+import { Callable } from '../util/Callable';
 import { EV, Expr, ExprData } from './Expr';
+import { Fields } from './Fields';
 export declare enum ColumnType {
     String = "String",
     Integer = "Integer",
@@ -7,7 +9,7 @@ export declare enum ColumnType {
     Json = "Json"
 }
 interface PartialColumnData {
-    type: ColumnType;
+    type?: ColumnType;
     name?: string;
     nullable?: boolean;
     defaultValue?: ExprData | (() => ExprData);
@@ -21,38 +23,81 @@ export interface ColumnData extends PartialColumnData {
     type: ColumnType;
     name: string;
 }
-export declare class Column<T> extends Expr<T> {
-    data: PartialColumnData;
-    constructor(data: PartialColumnData);
-    name(name: string): Column<T>;
-    nullable(): Column<T | null>;
-    autoIncrement(): OptionalColumn<T>;
-    primaryKey<K = string>(create?: () => EV<T>): PrimaryColumn<T, K>;
-    references<X extends T>(column: Expr<X> | (() => Expr<X>)): Column<X>;
-    unique(): this;
-    defaultValue(create: () => EV<T>): OptionalColumn<T>;
-    defaultValue(value: EV<T>): OptionalColumn<T>;
+export interface Column<T> {
+    [Column.type]: T;
+    [Column.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;
 }
-export declare class OptionalColumn<T> extends Column<T> {
+interface ValueColumn<T> extends Expr<T> {
+    <X = T>(): ValueColumn<T extends X ? T : Array<any> | null extends T ? Array<X> | null : T extends Array<any> ? Array<X> : T extends null ? X | null : X>;
+}
+declare class ValueColumn<T> extends Callable implements Column<T> {
+    [Column.type]: T;
+    [Column.data]: PartialColumnData;
+    constructor(data: PartialColumnData);
+    get nullable(): ValueColumn<T | null>;
+    get unique(): ValueColumn<T>;
+    get autoIncrement(): OptionalColumn<T>;
+    primaryKey<K = string>(create?: () => EV<T>): PrimaryColumn<T, K>;
+    references<X extends T>(column: Expr<X> | (() => Expr<X>)): ValueColumn<X>;
+    defaultValue(value: DefaultValue<T>): OptionalColumn<T>;
+}
+export declare class OptionalColumn<T> extends ValueColumn<T> {
     [Column.isOptional]: true;
 }
-export declare class PrimaryColumn<T, K> extends Column<PrimaryKey<T, K>> {
+export declare class PrimaryColumn<T, K> extends ValueColumn<PrimaryKey<T, K>> {
     [Column.isPrimary]: K;
 }
+interface ObjectColumn<T> {
+    <X = T>(): Column<T extends X ? T : T extends null ? X | null : X> & Fields<X>;
+}
+declare class ObjectColumn<T> extends Callable implements Column<T> {
+    [Column.type]: T;
+    [Column.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;
+}
 export type PrimaryKey<T, K> = string extends K ? T : T & {
     [Column.isPrimary]: K;
 };
-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>;
-    json<T_4 = any>(): Column<T_4>;
-    object<T_5 extends object = object>(): Column<T_5> & Expr<T_5> & { [K in keyof T_5]: Expr<T_5[K]>; };
-    array<T_6 = any>(): Column<T_6[]>;
-};
+type DefaultValue<T> = EV<T> | (() => EV<T>);
+interface UnTyped {
+    (name: string): UnTyped;
+}
+declare class UnTyped extends Callable {
+    [Column.data]: PartialColumnData;
+    constructor(data?: PartialColumnData);
+    get nullable(): NullableUnTyped;
+    get unique(): UnTyped;
+    get string(): ValueColumn<string>;
+    get integer(): ValueColumn<number>;
+    get number(): ValueColumn<number>;
+    get boolean(): ValueColumn<boolean>;
+    get json(): ValueColumn<any>;
+    get object(): ObjectColumn<{}>;
+    get array(): ValueColumn<any[]>;
+}
+declare class NullableUnTyped {
+    [Column.data]: PartialColumnData;
+    get unique(): UnTyped;
+    get string(): ValueColumn<string | null>;
+    get integer(): ValueColumn<number | null>;
+    get number(): ValueColumn<number | null>;
+    get boolean(): ValueColumn<boolean | null>;
+    get json(): ValueColumn<any | null>;
+    get object(): ObjectColumn<{} | null>;
+    get array(): ValueColumn<Array<any> | null>;
+}
+export declare const column: UnTyped;
 export {};

package/dist/define/Column.js

@@ -1,4 +1,5 @@
 // src/define/Column.ts
+import { Callable } from "../util/Callable.js";
 import { Expr, ExprData } from "./Expr.js";
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";
@@ -8,80 +9,149 @@ var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["Json"] = "Json";
   return ColumnType2;
 })(ColumnType || {});
-var Column = class extends Expr {
+var Column;
+((Column2) => {
+  Column2.data = Symbol("columnData");
+  Column2.type = Symbol("columnType");
+})(Column || (Column = {}));
+var ValueColumn = class extends Callable {
+  [Column.type];
+  [Column.data];
   constructor(data) {
-    super(void 0);
-    this.data = data;
+    super((defaultValue) => {
+      return new ValueColumn({
+        ...this[Column.data],
+        defaultValue: createDefaultValue(defaultValue)
+      });
+    });
+    this[Column.data] = data;
   }
-  name(name) {
-    return new Column({ ...this.data, name });
+  get nullable() {
+    return new ValueColumn({ ...this[Column.data], nullable: true });
   }
-  nullable() {
-    return new Column({ ...this.data, nullable: true });
+  get unique() {
+    return new ValueColumn({ ...this[Column.data], unique: true });
   }
-  autoIncrement() {
-    return new OptionalColumn({ ...this.data, autoIncrement: true });
+  get autoIncrement() {
+    return new OptionalColumn({ ...this[Column.data], autoIncrement: true });
   }
   primaryKey(create) {
     return new PrimaryColumn({
-      ...this.data,
+      ...this[Column.data],
       primaryKey: true,
-      defaultValue: create ? () => ExprData.create(create()) : this.data.defaultValue
+      defaultValue: create ? () => ExprData.create(create()) : this[Column.data].defaultValue
     });
   }
   references(column2) {
-    return new Column({
-      ...this.data,
+    return new ValueColumn({
+      ...this[Column.data],
       references() {
-        return ExprData.create(typeof column2 === "function" ? column2() : column2);
+        return ExprData.create(column2 instanceof Expr ? column2 : column2());
       }
     });
   }
-  unique() {
-    return new Column({ ...this.data, unique: true });
-  }
   defaultValue(value) {
     return new OptionalColumn({
-      ...this.data,
-      defaultValue: typeof value === "function" ? () => ExprData.create(value()) : ExprData.create(value)
+      ...this[Column.data],
+      defaultValue: createDefaultValue(value)
     });
   }
 };
-((Column2) => {
-})(Column || (Column = {}));
-var OptionalColumn = class extends Column {
+function createDefaultValue(value) {
+  return typeof value === "function" && !(value instanceof Expr) ? () => ExprData.create(value()) : ExprData.create(value);
+}
+var OptionalColumn = class extends ValueColumn {
   [Column.isOptional];
 };
-var PrimaryColumn = class extends Column {
+var PrimaryColumn = class extends ValueColumn {
   [Column.isPrimary];
 };
-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 */ });
-  },
-  json() {
-    return new Column({ type: "Json" /* Json */ });
-  },
-  object() {
-    return new Column({ type: "Json" /* Json */ });
-  },
-  array() {
-    return new Column({ type: "Json" /* Json */ });
+var ObjectColumn = class extends Callable {
+  [Column.type];
+  [Column.data];
+  constructor(data) {
+    super(() => this);
+    this[Column.data] = data;
+  }
+  get nullable() {
+    return new ObjectColumn({ ...this[Column.data], nullable: true });
+  }
+  get unique() {
+    return new ObjectColumn({ ...this[Column.data], unique: true });
+  }
+  defaultValue(value) {
+    return new OptionalObjectColumn({
+      ...this[Column.data],
+      defaultValue: createDefaultValue(value)
+    });
+  }
+};
+var OptionalObjectColumn = class extends ObjectColumn {
+  [Column.isOptional];
+};
+var UnTyped = class extends Callable {
+  [Column.data];
+  constructor(data = {}) {
+    super((name) => {
+      return new ValueColumn({ ...data, name });
+    });
+    this[Column.data] = data;
+  }
+  get nullable() {
+    return new UnTyped({ ...this[Column.data], nullable: true });
+  }
+  get unique() {
+    return new UnTyped({ ...this[Column.data], unique: true });
+  }
+  get string() {
+    return new ValueColumn({
+      ...this[Column.data],
+      type: "String" /* String */
+    });
+  }
+  get integer() {
+    return new ValueColumn({
+      ...this[Column.data],
+      type: "Integer" /* Integer */
+    });
+  }
+  get number() {
+    return new ValueColumn({
+      ...this[Column.data],
+      type: "Number" /* Number */
+    });
+  }
+  get boolean() {
+    return new ValueColumn({
+      ...this[Column.data],
+      type: "Boolean" /* Boolean */
+    });
+  }
+  get json() {
+    return new ValueColumn({
+      ...this[Column.data],
+      type: "Json" /* Json */
+    });
+  }
+  get object() {
+    return new ObjectColumn({
+      ...this[Column.data],
+      type: "Json" /* Json */
+    });
+  }
+  get array() {
+    return new ValueColumn({
+      ...this[Column.data],
+      type: "Json" /* Json */
+    });
   }
 };
+var column = new UnTyped();
 export {
   Column,
   ColumnType,
   OptionalColumn,
+  OptionalObjectColumn,
   PrimaryColumn,
   column
 };

package/dist/define/Expr.d.ts

@@ -126,7 +126,10 @@ export declare const ExprData: {
 };
 /** Expression or value of type T */
 export type EV<T> = Expr<T> | T;
-export declare class Expr<T> {
+declare class Empty {
+}
+declare const callable: typeof Empty;
+export declare class Expr<T> extends callable {
     expr: ExprData;
     static NULL: Expr<null>;
     static toExpr: symbol;
@@ -172,3 +175,4 @@ export declare namespace Expr {
         [K in keyof T]: Expr<T[K]>;
     };
 }
+export {};

package/dist/define/Expr.js

@@ -9,6 +9,7 @@ var __publicField = (obj, key, value) => {
 import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";
+var { fromEntries, entries, getPrototypeOf } = Object;
 var UnOpType = /* @__PURE__ */ ((UnOpType2) => {
   UnOpType2["Not"] = "Not";
   UnOpType2["IsNull"] = "IsNull";
@@ -91,17 +92,14 @@ var ExprData = {
   create(input) {
     if (input === null || input === void 0)
       return ExprData.Param(ParamData.Value(null));
-    if (input && typeof input[Expr.toExpr] === "function")
+    if (input && (typeof input === "function" || typeof input === "object") && input[Expr.toExpr])
       input = input[Expr.toExpr]();
     if (input instanceof Expr)
       return input.expr;
     if (input && typeof input === "object" && !Array.isArray(input))
       return ExprData.Record(
-        Object.fromEntries(
-          Object.entries(input).map(([key, value]) => [
-            key,
-            ExprData.create(value)
-          ])
+        fromEntries(
+          entries(input).map(([key, value]) => [key, ExprData.create(value)])
         )
       );
     return ExprData.Param(ParamData.Value(input));
@@ -121,14 +119,33 @@ function isConstant(e, value) {
       return false;
   }
 }
-var _Expr = class {
+function dotAccess(expr, path) {
+  return new Expr(ExprData.Field(expr.expr, path.join(".")));
+}
+function exprAccess(expr, ...path) {
+  return new Proxy(expr, {
+    apply(target, thisArg, args) {
+      const proto = getPrototypeOf(expr);
+      const method = path.pop();
+      const e = path.length > 0 ? dotAccess(expr, path) : expr;
+      return proto[method].apply(e, args);
+    },
+    get(_, key) {
+      const e = path.length > 0 ? dotAccess(expr, path) : expr;
+      if (key === "expr")
+        return e.expr;
+      if (typeof key !== "string")
+        return e[key];
+      return exprAccess(expr, ...path, key);
+    }
+  });
+}
+var callable = Function;
+var _Expr = class extends callable {
   constructor(expr) {
+    super();
     this.expr = expr;
-    return new Proxy(this, {
-      get(target, key) {
-        return key in target ? target[key] : target.get(key);
-      }
-    });
+    return exprAccess(this);
   }
   static value(value) {
     return new _Expr(ExprData.Param(ParamData.Value(value)));

package/dist/define/Fields.d.ts

@@ -1,10 +1,9 @@
-import { OptionalColumn, PrimaryColumn, PrimaryKey } from './Column';
 import { Expr } from './Expr';
 type ObjectUnion<T> = {
     [K in T extends infer P ? keyof P : never]: T extends infer P ? K extends keyof P ? P[K] : never : never;
 };
 type RecordField<T> = Expr<T> & FieldsOf<ObjectUnion<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [PrimaryColumn<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [OptionalColumn<infer V>] ? Field<V> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
+type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [number | string | boolean] ? Expr<T> : [T] extends [Record<string, any> | null] ? RecordField<T> : Expr<T>;
 type FieldsOf<Row> = Row extends Record<string, any> ? {
     [K in keyof Row]-?: Field<Row[K]>;
 } : never;

package/dist/define/Table.d.ts

@@ -14,16 +14,15 @@ export interface TableData {
         indexes: Record<string, IndexData>;
     };
 }
-interface TableProto<Definition> {
+export interface TableInstance<Definition> {
     (conditions: {
         [K in keyof Definition]?: Definition[K] extends Column<infer V> ? EV<V> : never;
     }): Cursor.TableSelect<Definition>;
     (...conditions: Array<EV<boolean>>): Cursor.TableSelect<Definition>;
 }
-declare class TableProto<Definition> {
+export declare class TableInstance<Definition> {
     [Selection.__tableType](): Table.Select<Definition>;
     get [table.data](): TableData;
-    [table.meta](): TableMeta;
     get name(): unknown;
     get length(): unknown;
     get call(): unknown;
@@ -31,7 +30,7 @@ declare class TableProto<Definition> {
     get bind(): unknown;
     get prototype(): unknown;
 }
-export type Table<Definition> = Definition & TableProto<Definition>;
+export type Table<Definition> = Definition & TableInstance<Definition>;
 export declare namespace Table {
     export type Of<Row> = Table<{
         [K in keyof Row as K extends string ? K : never]: Column<Row[K]>;

package/dist/define/Table.js

@@ -2,7 +2,6 @@
 import { Column } from "./Column.js";
 import { Cursor } from "./Cursor.js";
 import { BinOpType, Expr, ExprData } from "./Expr.js";
-import { Selection } from "./Selection.js";
 import { Target } from "./Target.js";
 var {
   keys,
@@ -15,39 +14,6 @@ var {
   getOwnPropertyDescriptor
 } = Object;
 var { ownKeys } = Reflect;
-var TableProto = class {
-  [Selection.__tableType]() {
-    throw "assert";
-  }
-  get [table.data]() {
-    throw "assert";
-  }
-  [table.meta]() {
-    throw "assert";
-  }
-  // Clear the Function prototype, not sure if there's a better way
-  // as mapped types (Omit) will remove the callable signature. We define them
-  // in a class getter since it's the only way to also mark them as non-enumarable
-  // Seems open: Microsoft/TypeScript#27575
-  get name() {
-    throw "assert";
-  }
-  get length() {
-    throw "assert";
-  }
-  get call() {
-    throw "assert";
-  }
-  get apply() {
-    throw "assert";
-  }
-  get bind() {
-    throw "assert";
-  }
-  get prototype() {
-    throw "assert";
-  }
-};
 function keysOf(input) {
   const methods = [];
   while (input = getPrototypeOf(input)) {
@@ -90,7 +56,7 @@ function createTable(data) {
   const ownKeys2 = ["prototype", ...cols];
   let res;
   if (!hasKeywords) {
-    res = assign(call, expressions, { [table.data]: data });
+    res = assign(call, expressions, { [table.data]: data, [Expr.toExpr]: toExpr });
     setPrototypeOf(call, getPrototypeOf(data.definition));
   } else {
     let get2 = function(key) {
@@ -135,13 +101,14 @@ function table(define) {
     columns: fromEntries(
       entries(getOwnPropertyDescriptors(columns)).map(([name2, descriptor]) => {
         const column = columns[name2];
-        if (!(column instanceof Column))
-          throw new Error(`Property ${name2} is not a column`);
-        const { data } = column;
+        const data = column[Column.data];
+        if (!data.type)
+          throw new Error(`Column ${name2} has no type`);
         return [
           name2,
           {
             ...data,
+            type: data.type,
             name: data.name || name2,
             enumerable: descriptor.enumerable
           }

package/dist/lib/Driver.d.ts

@@ -3,11 +3,9 @@ import { Expr } from '../define/Expr';
 import { Query } from '../define/Query';
 import { SchemaInstructions } from '../define/Schema';
 import { Table } from '../define/Table';
+import { Callable } from '../util/Callable';
 import { Formatter } from './Formatter';
 import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);

package/dist/lib/Driver.js

@@ -5,16 +5,7 @@ import { ParamData } from "../define/Param.js";
 import { Query, QueryType } from "../define/Query.js";
 import { Schema } from "../define/Schema.js";
 import { table } from "../define/Table.js";
-var Callable = class extends Function {
-  constructor(fn) {
-    super();
-    return new Proxy(this, {
-      apply(_, thisArg, input) {
-        return fn.apply(thisArg, input);
-      }
-    });
-  }
-};
+import { Callable } from "../util/Callable.js";
 function isTemplateStringsArray(input) {
   return Boolean(Array.isArray(input) && input.raw);
 }

package/dist/{lib → util}/Callable.js

@@ -1,4 +1,4 @@
-// src/lib/Callable.ts
+// src/util/Callable.ts
 var Callable = class extends Function {
   constructor(fn) {
     super();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",