rado 0.1.8 → 0.1.10

package/dist/Column.d.ts

@@ -20,23 +20,28 @@ export interface ColumnData extends PartialColumnData {
     type: ColumnType;
     name: string;
 }
-export declare class Column<T = any> {
+export declare class Column<T> {
     data: PartialColumnData;
     constructor(data: PartialColumnData);
     name(name: string): Column<T>;
     nullable(): Column<T | null>;
-    autoIncrement(): Column<T & Column.Optional>;
-    primaryKey(): Column<T & Column.Optional>;
-    references(column: Expr<T>): Column<any>;
+    autoIncrement(): Column<Column.Optional<T>>;
+    primaryKey<K extends string>(): Column<Column.Primary<K, T>>;
+    references(column: Expr<T>): Column<T>;
     unique(): Column<T>;
-    defaultValue(value: T): Column<T & Column.Optional>;
+    defaultValue(value: T): Column<Column.Optional<T>>;
 }
 export declare namespace Column {
     const isOptional: unique symbol;
-    export type Optional = {
+    type Optional<T> = {
         [isOptional]: true;
+        __t: T;
+    };
+    const isPrimary: unique symbol;
+    type Primary<Of, T> = {
+        [isPrimary]: Of;
+        __t: T;
     };
-    export {};
 }
 export declare const column: {
     string<T extends string = string>(): Column<T>;

package/dist/Column.js

@@ -34,6 +34,8 @@ var Column = class {
     return new Column({ ...this.data, defaultValue: value });
   }
 };
+((Column2) => {
+})(Column || (Column = {}));
 var column = {
   string() {
     return new Column({ type: "String" /* String */ });

package/dist/Expr.d.ts

@@ -147,3 +147,8 @@ export declare class Expr<T> {
     sure(): Expr<NonNullable<T>>;
     get<T>(name: string): Expr<T>;
 }
+export declare namespace Expr {
+    type Record<T> = Expr<T> & {
+        [K in keyof T]: Expr<T[K]>;
+    };
+}

package/dist/Fields.d.ts

@@ -1,9 +1,12 @@
 import { Column } from './Column';
 import { Expr } from './Expr';
-type Field<T> = [T] extends [Array<any>] ? Expr<T> : [T] extends [Column.Optional & infer V] ? Field<V> : [T] extends [Record<string, any>] ? FieldsOf<T> : Expr<T>;
+type RecordField<T> = Expr<T> & FieldsOf<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 : Field<T>;
+export type Fields<T> = IsStrictlyAny<T> extends true ? any : T extends object ? FieldsOf<T> : Field<T>;
 export {};

package/dist/Id.d.ts

@@ -0,0 +1,3 @@
+export type Id<T extends {
+    id: any;
+}> = T['id'];

package/dist/Table.d.ts

@@ -5,16 +5,16 @@ import { Fields } from './Fields';
 import { Schema } from './Schema';
 import { Selection } from './Selection';
 import { Update } from './Update';
-export declare class Table<T> extends Cursor.SelectMultiple<T> {
-    [Selection.__tableType](): T;
+export declare class Table<T> extends Cursor.SelectMultiple<Table.Normalize<T>> {
+    [Selection.__tableType](): Table.Normalize<T>;
     constructor(schema: Schema);
-    insertOne(record: Table.Insert<T>): Cursor.Batch<T>;
+    insertOne(record: Table.Insert<T>): Cursor.Batch<Table.Normalize<T>>;
     insertAll(data: Array<Table.Insert<T>>): Cursor.InsertValues;
-    set(data: Update<T>): Cursor.Update<T>;
+    set(data: Update<Table.Normalize<T>>): Cursor.Update<Table.Normalize<T>>;
     createTable(): Cursor.Create;
     as(alias: string): Table<T> & Fields<T>;
     get(name: string): Expr<any>;
-    toExpr(): Expr<T>;
+    toExpr(): Expr<Table.Normalize<T>>;
     schema(): Schema;
 }
 export declare namespace Table {
@@ -22,15 +22,21 @@ 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.Optional ? K : never;
+        [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;
     }[keyof T];
     type RequiredKeys<T> = {
-        [K in keyof T]: null extends T[K] ? never : T[K] extends Column.Optional ? never : K;
+        [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;
     }[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.Optional<infer V> ? V : 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];
+    };
+    export type Infer<T> = T extends Table<infer U> ? Normalize<U> : never;
     export {};
 }
 export interface TableOptions<T> {
@@ -46,5 +52,5 @@ export interface TableOptions<T> {
 }
 export declare function table<T extends {}>(options: TableOptions<T>): Table<T> & Fields<T>;
 export declare namespace table {
-    type infer<T> = T extends Table<infer U> ? U : never;
+    type infer<T> = Table.Infer<T>;
 }

package/dist/Table.js

@@ -62,7 +62,9 @@ var Table = class extends Cursor.SelectMultiple {
     return new Expr(ExprData.Field(this.toExpr().expr, name));
   }
   toExpr() {
-    return new Expr(ExprData.Row(Target.Table(this.schema())));
+    return new Expr(
+      ExprData.Row(Target.Table(this.schema()))
+    );
   }
   schema() {
     throw new Error("Not implemented");

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './Expr';
 export * from './Fields';
 export * from './Formatter';
 export * from './Functions';
+export * from './Id';
 export * from './Ops';
 export * from './OrderBy';
 export * from './Param';

package/dist/index.js

@@ -6,6 +6,7 @@ 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";

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "rado",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "license": "MIT",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
+    "./sqlite": "./dist/sqlite/index.js",
     "./*": "./dist/*.js"
   },
   "files": [
@@ -19,9 +20,9 @@
     }
   },
   "scripts": {
-    "build": "tsc && tsx build.ts",
+    "build": "tsc -p tsconfig.build.json && tsx build.ts",
     "test": "tsx test",
-    "prepublishOnly": "tsc && tsx build.ts"
+    "prepublishOnly": "tsc -p tsconfig.build.json && tsx build.ts"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^5.4.1",