edinburgh 0.6.0 → 0.6.2

package/src/indexes.ts

@@ -22,6 +22,17 @@ type IndexArgTypes<ITEM, F extends readonly (keyof ITEM & string)[]> = {
     [I in keyof F]: ITEM[F[I]]
 };
 
+function serializeIndexArg(fieldType: TypeWrapper<any>, arg: any, pack: DataPack) {
+    const linkedModel = fieldType.getLinkedModel();
+    if (!linkedModel || arg instanceof linkedModel) {
+        fieldType.serialize(arg, pack);
+        return;
+    }
+
+    // Link lookups may pass the target row's primary key instead of a loaded instance.
+    pack.write(linkedModel._argsToKeyBytes(Array.isArray(arg) ? arg : [arg], false).toUint8Array());
+}
+
 const MAX_INDEX_ID_PREFIX = -1;
 const INDEX_ID_PREFIX = -2;
 const VERSION_INFO_PREFIX = -3;
@@ -88,7 +99,10 @@ type ArrayOrOnlyItem<ARG_TYPES extends readonly any[]> = ARG_TYPES extends reado
  * exclusive bounds via `after` / `before`, and reverse scans.
  *
  * For single-field indexes, values can be passed directly. For composite indexes,
- * pass tuples or partial tuples for prefix matching.
+ * pass tuples or partial tuples for prefix matching. If an index field is a
+ * `link(...)`, you may pass either the linked model instance or the linked
+ * model's primary key. Composite linked primary keys are passed as tuples in
+ * that slot.
  *
  * @template ARG_TYPES - Tuple of index argument types.
  * @template FETCH - Optional fetch mode used by overloads that return one row.
@@ -182,7 +196,7 @@ export abstract class BaseIndex<ITEM, const F extends readonly (keyof ITEM & str
             let index = 0;
             for (const fieldType of this._indexFields.values()) {
                 if (index >= args.length) break;
-                fieldType.serialize(args[index++], bytes);
+                serializeIndexArg(fieldType, args[index++], bytes);
             }
         }
         return bytes;

package/src/models.ts

@@ -1,7 +1,7 @@
 import * as lowlevel from "olmdb/lowlevel";
 import { DatabaseError } from "olmdb/lowlevel";
 import DataPack from "./datapack.js";
-import { deserializeType, serializeType, TypeWrapper, identifier } from "./types.js";
+import { deserializeType, serializeType, TypeWrapper, identifier, type FieldQueryArg, type FieldValue } from "./types.js";
 import { transact, currentTxn, type Transaction } from "./edinburgh.js";
 
 import { PrimaryKey, NonPrimaryIndex, IndexRangeIterator, UniqueIndex, SecondaryIndex, FindOptions, VersionInfo } from "./indexes.js";
@@ -49,7 +49,7 @@ export interface FieldConfig<T> {
  * });
  * ```
  */
-export function field<T>(type: TypeWrapper<T>, options: Partial<FieldConfig<T>> = {}): T {
+export function field<TYPE extends TypeWrapper<any>>(type: TYPE, options: Partial<FieldConfig<FieldValue<TYPE>>> = {}): FieldValue<TYPE> {
     // Return the config object, but TypeScript sees it as type T
     options.type = type;
     return options as any;
@@ -68,16 +68,16 @@ type FieldsOf<T> = T extends new () => infer I ? I : never;
 
 type PKArgs<FIELDS, PK> =
     PK extends readonly (keyof FIELDS & string)[]
-        ? { [I in keyof PK]: PK[I] extends keyof FIELDS ? FIELDS[PK[I]] : never }
+        ? { [I in keyof PK]: PK[I] extends keyof FIELDS ? FieldQueryArg<FIELDS[PK[I]]> : never }
         : PK extends keyof FIELDS & string
-            ? [FIELDS[PK]]
+            ? [FieldQueryArg<FIELDS[PK]>]
             : [string];
 
 type IndexArgs<FIELDS, SPEC> =
     SPEC extends readonly (keyof FIELDS & string)[]
-        ? { [I in keyof SPEC]: SPEC[I] extends keyof FIELDS ? FIELDS[SPEC[I]] : never }
+        ? { [I in keyof SPEC]: SPEC[I] extends keyof FIELDS ? FieldQueryArg<FIELDS[SPEC[I]]> : never }
     : SPEC extends keyof FIELDS & string
-        ? [FIELDS[SPEC]]
+        ? [FieldQueryArg<FIELDS[SPEC]>]
     : SPEC extends (instance: any) => infer R
         ? R extends (infer V)[] ? [V] : [R]
     : never;
@@ -209,7 +209,7 @@ class ModelClassRuntime<FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX =
             key = args;
         } else {
             key = this._argsToKeyBytes(args, false).toUint8Array();
-            keyParts = args;
+            keyParts = this._pkToArray(key);
         }
 
         const keyHash = hashBytes(key);
@@ -269,6 +269,10 @@ class ModelClassRuntime<FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX =
 
     /**
      * Load a model by primary key inside the current transaction.
+        *
+        * For `link(...)` primary-key fields, each argument may be the linked model
+        * instance or the linked model's primary key. Composite linked primary keys
+        * are passed as a tuple in that argument slot.
      *
      * @returns The matching model, or `undefined` if no row exists.
      */
@@ -278,6 +282,8 @@ class ModelClassRuntime<FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX =
 
     /**
      * Load a model by primary key without fetching its non-key fields immediately.
+        *
+        * Link-valued primary-key fields accept the same shorthand as `get()`.
      *
      * Accessing a lazy field later will load the remaining fields transparently.
      */
@@ -321,7 +327,9 @@ class ModelClassRuntime<FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX =
      * Look up a model through a named unique index.
      *
      * @param name The name from the model's `unique` definition.
-     * @param args The unique-index key values.
+        * @param args The unique-index key values. For `link(...)` fields, pass
+        * either the linked model instance or the linked model's primary key. If the
+        * linked model uses a composite primary key, pass the full tuple in that slot.
      * @returns The matching model instance, if any.
      */
     getBy<K extends string & keyof UNIQUE>(name: K, ...args: IndexArgs<FIELDS, UNIQUE[K]>): Model<FIELDS> | undefined {
@@ -332,7 +340,8 @@ class ModelClassRuntime<FIELDS, PKA extends readonly any[], UNIQUE = {}, INDEX =
      * Query rows through a named unique or secondary index.
      *
      * This mirrors `find()`, but targets a named entry from the model's `unique`
-     * or `index` registration.
+        * or `index` registration. Link-valued index fields accept either the linked
+        * model instance or the linked model's primary key tuple/value.
      */
     findBy<K extends string & keyof (UNIQUE & INDEX)>(name: K, opts: FindOptions<IndexArgs<FIELDS, (UNIQUE & INDEX)[K]>, 'first'>): Model<FIELDS> | undefined;
     findBy<K extends string & keyof (UNIQUE & INDEX)>(name: K, opts: FindOptions<IndexArgs<FIELDS, (UNIQUE & INDEX)[K]>, 'single'>): Model<FIELDS>;

package/src/types.ts

@@ -87,6 +87,35 @@ export interface TypeWrapper<T> {
     default?(model: any): T;
 }
 
+// Hidden type-only metadata used to widen lookup arguments without widening assignment types.
+export declare const QUERY_ARG: unique symbol;
+
+export type LinkTargetPKArgs<T extends new (...args: any) => any> =
+    T extends { get(...args: infer PKA): any } ? PKA : never;
+
+export type LinkPrimaryKeyInput<PKA extends readonly any[]> =
+    PKA extends readonly [infer ONLY]
+        ? ONLY | PKA
+        : PKA;
+
+type QueryArgCarrier<QUERY> = {
+    readonly [QUERY_ARG]?: QUERY;
+};
+
+type QueryAnnotated<T, QUERY> = T & QueryArgCarrier<QUERY>;
+
+export type FieldValue<TYPE extends TypeWrapper<any>> =
+    TYPE extends TypeWrapper<infer T>
+        ? TYPE extends { readonly [QUERY_ARG]?: infer QUERY }
+            ? QueryAnnotated<T, Exclude<QUERY, undefined>>
+            : T
+        : never;
+
+export type FieldQueryArg<T> =
+    T extends { readonly [QUERY_ARG]?: infer QUERY }
+        ? Exclude<QUERY, undefined>
+        : T;
+
 
 class StringType extends TypeWrapper<string> {
     kind = 'string';
@@ -620,7 +649,7 @@ export class LinkType<T extends new (...args: any[]) => Model<any>> extends Type
     }
 
     getLinkedModel(): AnyModelClass {
-        if (!('getLazy' in this.TargetModel)) this.TargetModel = (this.TargetModel as unknown as () => T)();
+        if (!('getLazy' in (this.TargetModel as any))) this.TargetModel = (this.TargetModel as unknown as () => T)();
         return this.TargetModel as any;
     }
     
@@ -795,7 +824,9 @@ export function record<const T>(inner: TypeWrapper<T>): TypeWrapper<Record<strin
 * }, { pk: "id" });
 * ```
 */
-export function link<const T extends new (...args: any[]) => Model<any>>(TargetModel: T): TypeWrapper<InstanceType<T>>;
+export function link<const T extends new (...args: any[]) => Model<any>>(
+    TargetModel: T,
+): TypeWrapper<InstanceType<T>> & QueryArgCarrier<InstanceType<T> | LinkPrimaryKeyInput<LinkTargetPKArgs<T>>>;
 export function link<const T extends new (...args: any[]) => Model<any>>(TargetModel: () => T): TypeWrapper<InstanceType<T>>;
 export function link(TargetModel: any): TypeWrapper<any> {
     return new LinkType(TargetModel);