rado 0.2.44 → 0.3.0

package/dist/define/Table.d.ts

@@ -6,12 +6,10 @@ import { Index, IndexData } from './Index.js';
 import type { Selection } from './Selection.js';
 import { SelectFirst } from './query/Select.js';
 import { TableSelect } from './query/TableSelect.js';
-interface TableDefinition {
-}
 export declare class TableData {
     name: string;
     alias?: string;
-    definition: TableDefinition;
+    definition: {};
     columns: Record<string, ColumnData>;
     meta: () => {
         indexes: Record<string, IndexData>;
@@ -29,6 +27,10 @@ export declare class TableInstance<Definition> {
     get [Table.Data](): TableData;
 }
 export type Table<Definition> = Definition & TableInstance<Definition>;
+declare class HasIndexes<Indexes extends string | number | symbol> {
+    get [Table.Indexes](): Record<Indexes, IndexData>;
+}
+export type IndexedTable<Definition, Indexes extends string | number | symbol> = Table<Definition> & HasIndexes<Indexes>;
 type TableOf<Row> = Table<{
     [K in keyof Row as K extends string ? K : never]: Column<Row[K]> & Fields<Row[K]>;
 }>;
@@ -40,7 +42,7 @@ type UpdateOf<Definition> = Partial<{
 }>;
 export declare namespace Table {
     export const Data: unique symbol;
-    export const Meta: unique symbol;
+    export const Indexes: unique symbol;
     export type Of<Row> = TableOf<Row>;
     export type Select<Definition> = RowOf<Definition>;
     export type Update<Definition> = UpdateOf<Definition>;
@@ -60,8 +62,11 @@ interface Define<T> {
 }
 export type table<T> = Table.Select<T extends Table<infer D> ? D : T>;
 export declare function createTable<Definition>(data: TableData): Table<Definition>;
-export declare function table<T extends {}>(define: Record<string, T | Define<T>>): Table<T>;
+export declare function table<T extends {}, Indexes extends Record<string, Index>>(define: {
+    [key: string]: T | Define<T>;
+    [Table.Indexes]?: (this: T) => Indexes;
+}): {} extends Indexes ? Table<T> : IndexedTable<T, keyof Indexes>;
 export declare namespace table {
-    const meta: typeof Table.Meta;
+    const indexes: typeof Table.Indexes;
 }
 export {};

package/dist/define/Table.js

@@ -23,7 +23,7 @@ class TableData {
 var Table;
 ((Table2) => {
   Table2.Data = Symbol("Table.Data");
-  Table2.Meta = Symbol("Table.Meta");
+  Table2.Indexes = Symbol("Table.Indexes");
 })(Table || (Table = {}));
 function createTable(data) {
   const target = new Target.Table(data);
@@ -61,6 +61,15 @@ function createTable(data) {
   for (const [key, value] of entries(expressions))
     defineProperty(call, key, { value, enumerable: true, configurable: true });
   defineProperty(call, Table.Data, { value: data, enumerable: false });
+  let indexes;
+  defineProperty(call, Table.Indexes, {
+    get() {
+      if (indexes)
+        return indexes;
+      return indexes = data.meta().indexes;
+    },
+    enumerable: false
+  });
   defineProperty(call, Expr.ToExpr, { value: toExpr, enumerable: false });
   setPrototypeOf(call, getPrototypeOf(data.definition));
   return call;
@@ -98,13 +107,13 @@ function table(define) {
         })
       ),
       meta() {
-        const createMeta = res[table.meta];
-        const meta = createMeta ? createMeta.apply(res) : {};
+        const createIndexes = define[Table.Indexes];
+        const indexes = createIndexes ? createIndexes.apply(res) : {};
         return {
           indexes: fromEntries(
-            entries(meta?.indexes || {}).map(([key, index]) => {
+            entries(indexes || {}).map(([key, index]) => {
               const indexName = `${name}.${key}`;
-              return [indexName, { name: indexName, ...index.data }];
+              return [key, { name: indexName, ...index.data }];
             })
           )
         };
@@ -114,7 +123,7 @@ function table(define) {
   return res;
 }
 ((table2) => {
-  table2.meta = Table.Meta;
+  table2.indexes = Table.Indexes;
 })(table || (table = {}));
 export {
   Table,

package/dist/define/Target.d.ts

@@ -1,4 +1,5 @@
 import type { ExprData } from './Expr.js';
+import { IndexData } from './Index.js';
 import type { QueryData } from './Query.js';
 import type { TableData } from './Table.js';
 export declare enum TargetType {
@@ -30,8 +31,9 @@ export declare namespace Target {
     }
     class Table {
         table: TableData;
+        indexedBy?: IndexData | undefined;
         type: TargetType.Table;
-        constructor(table: TableData);
+        constructor(table: TableData, indexedBy?: IndexData | undefined);
     }
     class Join {
         left: Target;

package/dist/define/Target.js

@@ -33,8 +33,9 @@ var Target;
   }
   Target2.Query = Query;
   class Table {
-    constructor(table) {
+    constructor(table, indexedBy) {
       this.table = table;
+      this.indexedBy = indexedBy;
     }
     type = "Target.Table" /* Table */;
   }

package/dist/define/query/Select.d.ts

@@ -1,4 +1,5 @@
 import { EV, Expr } from '../Expr.js';
+import { IndexData } from '../Index.js';
 import { OrderBy } from '../OrderBy.js';
 import { Query, QueryData } from '../Query.js';
 import { Selection } from '../Selection.js';
@@ -9,6 +10,7 @@ export declare class Select<Row> extends Union<Row> {
     [Query.Data]: QueryData.Select;
     constructor(query: QueryData.Select);
     from(table: Table<any> | VirtualTable<any>): Select<Row>;
+    indexedBy(index: IndexData): Select<unknown>;
     leftJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
     innerJoin<C>(that: Table<C> | Select<C>, ...on: Array<EV<boolean>>): Select<Row>;
     select<X extends Selection>(selection: X): Select<Selection.Infer<X>>;

package/dist/define/query/Select.js

@@ -2,7 +2,7 @@ import { Expr, ExprData } from "../Expr.js";
 import { Functions } from "../Functions.js";
 import { Query } from "../Query.js";
 import { Table } from "../Table.js";
-import { Target } from "../Target.js";
+import { Target, TargetType } from "../Target.js";
 import { VirtualTable } from "../VirtualTable.js";
 import { Union } from "./Union.js";
 function joinTarget(joinType, query, to, on) {
@@ -33,6 +33,19 @@ class Select extends Union {
       this[Query.Data].with({ from: virtual?.target || new Target.Table(table) })
     );
   }
+  indexedBy(index) {
+    const from = this[Query.Data].from;
+    switch (from?.type) {
+      case TargetType.Table:
+        return new Select(
+          this[Query.Data].with({
+            from: new Target.Table(from.table, index)
+          })
+        );
+      default:
+        throw new Error("Cannot index by without table target");
+    }
+  }
   leftJoin(that, ...on) {
     const query = this[Query.Data];
     return new Select(

package/dist/lib/Formatter.js

@@ -398,6 +398,9 @@ class Formatter {
         stmt.identifier(target.table.name);
         if (target.table.alias)
           stmt.add("AS").addIdentifier(target.table.alias);
+        if (target.indexedBy) {
+          stmt.add("INDEXED BY").addIdentifier(target.indexedBy.name);
+        }
         return stmt;
       case TargetType.Join:
         const { left, right, joinType } = target;

package/package.json

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