rado 0.1.11 → 0.1.13

package/dist/driver/better-sqlite3.d.ts

@@ -1,7 +1,7 @@
 import type { Database } from 'better-sqlite3';
-import { Driver } from '../Driver';
-import { SchemaInstructions } from '../Schema';
-import { Statement } from '../Statement';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
 export declare class BetterSqlite3Driver extends Driver.Sync {
     db: Database;
     constructor(db: Database);

package/dist/driver/better-sqlite3.js

@@ -1,5 +1,5 @@
 // src/driver/better-sqlite3.ts
-import { Driver } from "../Driver.js";
+import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var BetterSqlite3Driver = class extends Driver.Sync {

package/dist/driver/sql.js.d.ts

@@ -1,7 +1,7 @@
 import type { Database } from 'sql.js';
-import { Driver } from '../Driver';
-import { SchemaInstructions } from '../Schema';
-import { Statement } from '../Statement';
+import { Driver } from '../lib/Driver';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
 export declare class SqlJsDriver extends Driver.Sync {
     db: Database;
     constructor(db: Database);

package/dist/driver/sql.js.js

@@ -1,5 +1,5 @@
 // src/driver/sql.js.ts
-import { Driver } from "../Driver.js";
+import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var SqlJsDriver = class extends Driver.Sync {

package/dist/driver/sqlite3.d.ts

@@ -1,8 +1,8 @@
 import type { Database } from 'sqlite3';
-import { Driver } from '../Driver';
-import { Query } from '../Query';
-import { SchemaInstructions } from '../Schema';
-import { Statement } from '../Statement';
+import { Driver } from '../lib/Driver';
+import { Query } from '../lib/Query';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
 export declare class Sqlite3Driver extends Driver.Async {
     private db;
     lock: Promise<void> | undefined;

package/dist/driver/sqlite3.js

@@ -1,5 +1,5 @@
 // src/driver/sqlite3.ts
-import { Driver } from "../Driver.js";
+import { Driver } from "../lib/Driver.js";
 import { SqliteFormatter } from "../sqlite/SqliteFormatter.js";
 import { SqliteSchema } from "../sqlite/SqliteSchema.js";
 var Sqlite3Driver = class extends Driver.Async {

package/dist/index.d.ts

@@ -1,19 +1,20 @@
-export * from './Column';
-export * from './Cursor';
-export * from './Driver';
-export * from './Expr';
-export * from './Fields';
-export * from './Formatter';
-export * from './Functions';
-export * from './Id';
-export * from './Ops';
-export * from './OrderBy';
-export * from './Param';
-export * from './Query';
-export * from './Sanitizer';
-export * from './Schema';
-export * from './Selection';
-export * from './Statement';
-export * from './Table';
-export * from './Target';
-export * from './Update';
+export * from './lib/Column';
+export * from './lib/Cursor';
+export * from './lib/Driver';
+export * from './lib/Expr';
+export * from './lib/Fields';
+export * from './lib/Formatter';
+export * from './lib/Functions';
+export * from './lib/Id';
+export * from './lib/Index';
+export * from './lib/Ops';
+export * from './lib/OrderBy';
+export * from './lib/Param';
+export * from './lib/Query';
+export * from './lib/Sanitizer';
+export * from './lib/Schema';
+export * from './lib/Selection';
+export * from './lib/Statement';
+export * from './lib/Table';
+export * from './lib/Target';
+export * from './lib/Update';

package/dist/index.js

@@ -1,20 +1,21 @@
 // src/index.ts
-export * from "./Column.js";
-export * from "./Cursor.js";
-export * from "./Driver.js";
-export * from "./Expr.js";
-export * from "./Fields.js";
-export * from "./Formatter.js";
-export * from "./Functions.js";
-export * from "./Id.js";
-export * from "./Ops.js";
-export * from "./OrderBy.js";
-export * from "./Param.js";
-export * from "./Query.js";
-export * from "./Sanitizer.js";
-export * from "./Schema.js";
-export * from "./Selection.js";
-export * from "./Statement.js";
-export * from "./Table.js";
-export * from "./Target.js";
-export * from "./Update.js";
+export * from "./lib/Column.js";
+export * from "./lib/Cursor.js";
+export * from "./lib/Driver.js";
+export * from "./lib/Expr.js";
+export * from "./lib/Fields.js";
+export * from "./lib/Formatter.js";
+export * from "./lib/Functions.js";
+export * from "./lib/Id.js";
+export * from "./lib/Index.js";
+export * from "./lib/Ops.js";
+export * from "./lib/OrderBy.js";
+export * from "./lib/Param.js";
+export * from "./lib/Query.js";
+export * from "./lib/Sanitizer.js";
+export * from "./lib/Schema.js";
+export * from "./lib/Selection.js";
+export * from "./lib/Statement.js";
+export * from "./lib/Table.js";
+export * from "./lib/Target.js";
+export * from "./lib/Update.js";

package/dist/{Column.d.ts → lib/Column.d.ts}

@@ -25,21 +25,24 @@ export declare class Column<T> {
     constructor(data: PartialColumnData);
     name(name: string): Column<T>;
     nullable(): Column<T | null>;
-    autoIncrement(): Column<Column.Optional<T>>;
-    primaryKey<K extends string>(): Column<Column.Primary<K, T>>;
+    autoIncrement(): Column<Column.IsOptional<T>>;
+    primaryKey<K extends string>(): Column<Column.IsPrimary<T, K>>;
     references(column: Expr<T>): Column<T>;
     unique(): Column<T>;
-    defaultValue(value: T): Column<Column.Optional<T>>;
+    defaultValue(value: 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 Optional<T> = {
+    type IsOptional<T> = {
         [isOptional]: true;
         __t: T;
     };
     const isPrimary: unique symbol;
-    type Primary<Of, T> = {
-        [isPrimary]: Of;
+    type IsPrimary<T, K> = {
+        [isPrimary]: K;
         __t: T;
     };
 }

package/dist/{Column.js → lib/Column.js}

@@ -1,4 +1,4 @@
-// src/Column.ts
+// src/lib/Column.ts
 import { ExprData } from "./Expr.js";
 var ColumnType = /* @__PURE__ */ ((ColumnType2) => {
   ColumnType2["String"] = "String";

package/dist/{Cursor.js → lib/Cursor.js}

@@ -1,4 +1,4 @@
-// src/Cursor.ts
+// src/lib/Cursor.ts
 import { Expr, ExprData } from "./Expr.js";
 import { Functions } from "./Functions.js";
 import { Query } from "./Query.js";

package/dist/{Driver.js → lib/Driver.js}

@@ -1,4 +1,4 @@
-// src/Driver.ts
+// src/lib/Driver.ts
 import { Cursor } from "./Cursor.js";
 import { Query, QueryType } from "./Query.js";
 import { Schema } from "./Schema.js";

package/dist/{Expr.js → lib/Expr.js}

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 
-// src/Expr.ts
+// src/lib/Expr.ts
 import { OrderDirection } from "./OrderBy.js";
 import { ParamData, ParamType } from "./Param.js";
 import { Target } from "./Target.js";

package/dist/lib/Fields.d.ts

@@ -0,0 +1,13 @@
+import { Column, 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 [Column.IsPrimary<infer V, infer K>] ? Expr<PrimaryKey<V, K>> : [T] extends [Column.IsOptional<infer V>] ? Field<V> : [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;
+type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
+export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
+export {};

package/dist/{Formatter.d.ts → lib/Formatter.d.ts}

@@ -8,6 +8,7 @@ import { Target } from './Target';
 export interface FormatContext {
     nameResult?: string;
     skipTableName?: boolean;
+    forceInline?: boolean;
     formatAsJson?: boolean;
     formatSubject?: (subject: Statement) => Statement;
 }
@@ -50,6 +51,6 @@ export declare abstract class Formatter implements Sanitizer {
     formatField(expr: ExprData, field: string, ctx: FormatContext): Statement;
     formatString(input: string): Statement;
     formatInlineValue(rawValue: any): Statement;
-    formatValue(rawValue: any, formatAsJson?: boolean): Statement;
+    formatValue(rawValue: any, ctx: FormatContext): Statement;
     formatExpr(expr: ExprData, ctx: FormatContext): Statement;
 }

package/dist/{Formatter.js → lib/Formatter.js}

@@ -1,4 +1,4 @@
-// src/Formatter.ts
+// src/lib/Formatter.ts
 import { ColumnType } from "./Column.js";
 import { BinOp, ExprData, ExprType, UnOp } from "./Expr.js";
 import { OrderDirection } from "./OrderBy.js";
@@ -124,7 +124,11 @@ var Formatter = class {
     return raw("create index").addIf(query.ifNotExists, "if not exists").addIdentifier(query.index.name).add("on").addIdentifier(query.table.name).parenthesis(
       separated(
         query.index.on.map(
-          (expr) => this.formatExprValue(expr, { ...ctx, skipTableName: true })
+          (expr) => this.formatExprValue(expr, {
+            ...ctx,
+            skipTableName: true,
+            forceInline: true
+          })
         )
       )
     ).add(this.formatWhere(query.where, ctx));
@@ -349,7 +353,8 @@ var Formatter = class {
         return this.formatString(JSON.stringify(rawValue));
     }
   }
-  formatValue(rawValue, formatAsJson) {
+  formatValue(rawValue, ctx) {
+    const { formatAsJson, forceInline } = ctx;
     switch (true) {
       case (rawValue === null || rawValue === void 0):
         return raw("null");
@@ -357,10 +362,16 @@ var Formatter = class {
         return rawValue ? raw("1") : raw("0");
       case Array.isArray(rawValue):
         const res = parenthesis(
-          separated(rawValue.map((v) => this.formatValue(v, false)))
+          separated(
+            rawValue.map(
+              (v) => this.formatValue(v, { ...ctx, formatAsJson: false })
+            )
+          )
         );
         return formatAsJson ? raw("json_array").concat(res) : res;
       case (typeof rawValue === "string" || typeof rawValue === "number"):
+        if (forceInline)
+          return raw(this.escapeValue(rawValue));
         return value(rawValue);
       default:
         const expr = this.formatString(JSON.stringify(rawValue));
@@ -389,7 +400,7 @@ var Formatter = class {
       case ExprType.Param:
         switch (expr.param.type) {
           case ParamType.Value:
-            return this.formatValue(expr.param.value, ctx.formatAsJson);
+            return this.formatValue(expr.param.value, ctx);
           case ParamType.Named:
             throw new Error("todo");
         }

package/dist/{Functions.js → lib/Functions.js}

@@ -1,4 +1,4 @@
-// src/Functions.ts
+// src/lib/Functions.ts
 import { Expr, ExprData } from "./Expr.js";
 function get(_, method) {
   return (...args) => {

package/dist/lib/Index.d.ts

@@ -0,0 +1,15 @@
+import { Expr, ExprData } from './Expr';
+interface PartialIndexData {
+    on: Array<ExprData>;
+    where?: ExprData;
+}
+export interface IndexData extends PartialIndexData {
+    name: string;
+}
+export declare class Index {
+    data: PartialIndexData;
+    constructor(data: PartialIndexData);
+    where(where: Expr<boolean>): Index;
+}
+export declare function index(...on: Array<Expr<any>>): Index;
+export {};

package/dist/lib/Index.js

@@ -0,0 +1,17 @@
+// src/lib/Index.ts
+import { ExprData } from "./Expr.js";
+var Index = class {
+  constructor(data) {
+    this.data = data;
+  }
+  where(where) {
+    return new Index({ ...this.data, where: ExprData.create(where) });
+  }
+};
+function index(...on) {
+  return new Index({ on: on.map(ExprData.create) });
+}
+export {
+  Index,
+  index
+};

package/dist/{Ops.js → lib/Ops.js}

@@ -1,4 +1,4 @@
-// src/Ops.ts
+// src/lib/Ops.ts
 import { Cursor } from "./Cursor.js";
 import { ExprData } from "./Expr.js";
 import { Query } from "./Query.js";

package/dist/{OrderBy.js → lib/OrderBy.js}

@@ -1,4 +1,4 @@
-// src/OrderBy.ts
+// src/lib/OrderBy.ts
 var OrderDirection = /* @__PURE__ */ ((OrderDirection2) => {
   OrderDirection2["Asc"] = "Asc";
   OrderDirection2["Desc"] = "Desc";

package/dist/{Param.js → lib/Param.js}

@@ -1,4 +1,4 @@
-// src/Param.ts
+// src/lib/Param.ts
 var ParamType = /* @__PURE__ */ ((ParamType2) => {
   ParamType2["Value"] = "Value";
   ParamType2["Named"] = "Named";

package/dist/{Query.d.ts → lib/Query.d.ts}

@@ -1,7 +1,8 @@
 import { ColumnData } from './Column';
 import { ExprData } from './Expr';
+import { IndexData } from './Index';
 import { OrderBy } from './OrderBy';
-import { Index, Schema } from './Schema';
+import { Schema } from './Schema';
 import { Target } from './Target';
 export declare enum QueryType {
     Insert = "Insert",
@@ -61,7 +62,7 @@ export declare namespace Query {
     interface CreateIndex extends QueryBase {
         type: QueryType.CreateIndex;
         table: Schema;
-        index: Index;
+        index: IndexData;
         ifNotExists?: boolean;
     }
     function CreateIndex(create: Omit<CreateIndex, 'type'>): Query.CreateIndex;

package/dist/{Query.js → lib/Query.js}

@@ -1,4 +1,4 @@
-// src/Query.ts
+// src/lib/Query.ts
 var QueryType = /* @__PURE__ */ ((QueryType2) => {
   QueryType2["Insert"] = "Insert";
   QueryType2["Select"] = "Select";

package/dist/{Schema.d.ts → lib/Schema.d.ts}

@@ -1,17 +1,12 @@
 import { ColumnData } from './Column';
-import { ExprData } from './Expr';
 import { Formatter } from './Formatter';
+import { IndexData } from './Index';
 import { Query } from './Query';
-export interface Index {
-    name: string;
-    on: Array<ExprData>;
-    where?: ExprData;
-}
 export interface Schema {
     name: string;
     alias?: string;
     columns: Record<string, ColumnData>;
-    indexes: Record<string, Index>;
+    indexes: Record<string, IndexData>;
 }
 export interface SchemaInstructions {
     columns: Record<string, string>;

package/dist/{Schema.js → lib/Schema.js}

@@ -1,4 +1,4 @@
-// src/Schema.ts
+// src/lib/Schema.ts
 import { Query } from "./Query.js";
 var Schema;
 ((Schema2) => {

package/dist/{Selection.js → lib/Selection.js}

@@ -1,4 +1,4 @@
-// src/Selection.ts
+// src/lib/Selection.ts
 var Selection;
 ((Selection2) => {
 })(Selection || (Selection = {}));

package/dist/{Statement.js → lib/Statement.js}

@@ -1,4 +1,4 @@
-// src/Statement.ts
+// src/lib/Statement.ts
 var Token = class {
   constructor(type, data) {
     this.type = type;

package/dist/{Table.d.ts → lib/Table.d.ts}

@@ -1,7 +1,8 @@
-import { Column } from './Column';
+import { Column, PrimaryKey } from './Column';
 import { Cursor } from './Cursor';
 import { Expr } from './Expr';
 import { Fields } from './Fields';
+import { Index } from './Index';
 import { Schema } from './Schema';
 import { Selection } from './Selection';
 import { Update } from './Update';
@@ -22,19 +23,17 @@ export declare namespace Table {
         [P in keyof U]: U[P];
     } : never;
     type OptionalKeys<T> = {
-        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.Primary<any, any> ? K : T[K] extends Column.Optional<any> ? K : never;
+        [K in keyof T]: null extends T[K] ? K : T[K] extends Column.IsPrimary<any, any> ? K : T[K] extends Column.IsOptional<any> ? K : never;
     }[keyof T];
     type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.Primary<any, any> ? never : T[K] extends Column.Optional<any> ? never : K;
+        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.IsPrimary<any, any> ? never : T[K] extends Column.IsOptional<any> ? never : K;
     }[keyof T];
     type Optionals<T> = {
-        [K in keyof T]?: T[K] extends Column.Optional<infer V> ? V : T[K];
+        [K in keyof T]?: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
     };
     export type Insert<T> = Intersection<Optionals<Pick<T, OptionalKeys<T>>>, Pick<T, RequiredKeys<T>>>;
     export type Normalize<T> = {
-        [K in keyof T]: T[K] extends Column.Optional<infer V> ? V : T[K] extends Column.Primary<infer K, infer V> ? string extends K ? V : V & {
-            [Column.isPrimary]: K;
-        } : T[K];
+        [K in keyof T]: T[K] extends Column.IsOptional<infer V> ? V : T[K] extends Column.IsPrimary<infer V, infer K> ? PrimaryKey<V, K> : T[K];
     };
     export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
     export {};
@@ -45,10 +44,7 @@ export interface TableOptions<T> {
     columns: {
         [K in keyof T]: Column<T[K]>;
     };
-    indexes?: (this: Fields<T>) => Record<string, {
-        on: Array<Expr<any>>;
-        where?: Expr<boolean>;
-    }>;
+    indexes?: (this: Fields<T>) => Record<string, Index>;
 }
 export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
 export declare namespace table {

package/dist/{Table.js → lib/Table.js}

@@ -1,4 +1,4 @@
-// src/Table.ts
+// src/lib/Table.ts
 import { Cursor } from "./Cursor.js";
 import { Expr, ExprData } from "./Expr.js";
 import { Query } from "./Query.js";
@@ -92,8 +92,7 @@ function table(options) {
         indexName,
         {
           name: indexName,
-          on: index.on.map(ExprData.create),
-          where: index.where?.expr
+          ...index.data
         }
       ];
     })

package/dist/{Target.js → lib/Target.js}

@@ -1,4 +1,4 @@
-// src/Target.ts
+// src/lib/Target.ts
 var TargetType = /* @__PURE__ */ ((TargetType2) => {
   TargetType2["Each"] = "Each";
   TargetType2["Table"] = "Table";

package/dist/sqlite/SqliteFormatter.d.ts

@@ -1,6 +1,6 @@
-import { ExprData } from '../Expr';
-import { FormatContext, Formatter } from '../Formatter';
-import { Statement } from '../Statement';
+import { ExprData } from '../lib/Expr';
+import { FormatContext, Formatter } from '../lib/Formatter';
+import { Statement } from '../lib/Statement';
 export declare class SqliteFormatter extends Formatter {
     escapeValue(value: any): string;
     escapeIdentifier(input: string): string;

package/dist/sqlite/SqliteFormatter.js

@@ -1,8 +1,8 @@
 // src/sqlite/SqliteFormatter.ts
-import { ExprType } from "../Expr.js";
-import { Formatter } from "../Formatter.js";
-import { identifier } from "../Statement.js";
-import { TargetType } from "../Target.js";
+import { ExprType } from "../lib/Expr.js";
+import { Formatter } from "../lib/Formatter.js";
+import { identifier } from "../lib/Statement.js";
+import { TargetType } from "../lib/Target.js";
 function escapeWithin(input, outer) {
   let buf = outer;
   for (const char of input) {

package/dist/sqlite/SqliteFunctions.d.ts

@@ -1,5 +1,5 @@
-import { EV, Expr } from '../Expr';
-import { Table } from '../Table';
+import { EV, Expr } from '../lib/Expr';
+import { Table } from '../lib/Table';
 export declare const SqliteFunctions: SqliteFunctions;
 export type SqliteFunctions = {
     /** Use the match operator for the FTS5 module */

package/dist/sqlite/SqliteFunctions.js

@@ -1,5 +1,5 @@
 // src/sqlite/SqliteFunctions.ts
-import { Functions } from "../Functions.js";
+import { Functions } from "../lib/Functions.js";
 var SqliteFunctions = Functions;
 export {
   SqliteFunctions

package/dist/sqlite/SqliteSchema.d.ts

@@ -1,5 +1,5 @@
-import { SchemaInstructions } from '../Schema';
-import { Statement } from '../Statement';
+import { SchemaInstructions } from '../lib/Schema';
+import { Statement } from '../lib/Statement';
 export declare namespace SqliteSchema {
     type Column = {
         cid: number;

package/dist/sqlite/SqliteSchema.js

@@ -1,5 +1,5 @@
 // src/sqlite/SqliteSchema.ts
-import { Statement, identifier, raw } from "../Statement.js";
+import { Statement, identifier, raw } from "../lib/Statement.js";
 import { SqliteFormatter } from "./SqliteFormatter.js";
 var SqliteSchema;
 ((SqliteSchema2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "license": "MIT",
   "type": "module",
   "exports": {

package/dist/Fields.d.ts

@@ -1,16 +0,0 @@
-import { Column } from './Column';
-import { Expr } from './Expr';
-type GetKeys<U> = U extends Record<infer K, any> ? K : never;
-type UnionToIntersection<U> = {
-    [K in GetKeys<U>]: U extends Record<K, infer T> ? T : never;
-};
-type RecordField<T> = Expr<T> & FieldsOf<UnionToIntersection<T>>;
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.Primary<infer K, infer V>] ? Expr<string extends K ? V : V & {
-    [Column.isPrimary]: K;
-}> : [T] extends [Column.Optional<infer V>] ? Field<V> : [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;
-type IsStrictlyAny<T> = (T extends never ? true : false) extends false ? false : true;
-export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
-export {};