edinburgh 0.3.0 → 0.4.2

package/src/types.ts

@@ -1,8 +1,8 @@
-import { DataPack } from "./datapack.js";
-import * as olmdb from "olmdb";
-import { DatabaseError } from "olmdb";
-import { Model, modelRegistry, getMockModel } from "./models.js";
-import { assert, addErrorPath } from "./utils.js";
+import DataPack from "./datapack.js";
+import { DatabaseError } from "olmdb/lowlevel";
+import { Model, modelRegistry, FieldConfig, currentTxn } from "./models.js";
+import { assert, addErrorPath, dbGet } from "./utils.js";
+import { PrimaryIndex, BaseIndex, IndexRangeIterator } from "./indexes.js";
 
 
 /**
@@ -70,6 +70,10 @@ export abstract class TypeWrapper<const T> {
     equals(value1: T, value2: T): boolean {
         return value1 === value2;
     }
+
+    getLinkedModel(): (typeof Model<unknown>) | undefined {
+        return;
+    }
 }
 
 
@@ -226,6 +230,10 @@ class ArrayType<T> extends TypeWrapper<T[]> {
         return new ArrayType(inner);
     }
 
+    default(): T[] {
+        return [];
+    }
+
     clone(value: T[]): T[] {
         return value.map(this.inner.clone.bind(this.inner));
     }
@@ -238,6 +246,11 @@ class ArrayType<T> extends TypeWrapper<T[]> {
         return true;
     }
 
+    toString() { return `array<${this.inner}>`; }
+
+    getLinkedModel() {
+        return this.inner.getLinkedModel();
+    }
 }
 
 /**
@@ -320,6 +333,12 @@ export class SetType<T> extends TypeWrapper<Set<T>> {
         }
         return true;
     }
+
+    toString() { return `set<${this.inner}>`; }
+
+    getLinkedModel() {
+        return this.inner.getLinkedModel();
+    }
 }
 
 
@@ -398,6 +417,20 @@ class OrType<const T> extends TypeWrapper<T> {
         const cb = this._getChoiceIndex(b);
         return ca === cb && this.choices[ca].equals(a, b);
     }
+
+    toString() { return `or<${this.choices.join('|')}>`; }
+
+    getLinkedModel() {
+        let model;
+        for (const choice of this.choices) {
+            const m = choice.getLinkedModel();
+            if (m) {
+                if (model && model !== m) throw new DatabaseError(`Union type has multiple linked models, unsupported by getLinkedModel()`, 'INVALID_TYPE');
+                model = m;
+            }
+        }
+        return model;
+    }
 }
 
 /**
@@ -443,6 +476,8 @@ class LiteralType<const T> extends TypeWrapper<T> {
         return new LiteralType(value);
     }
     
+    toString() { return `literal<${JSON.stringify(this.value)}>`; }
+
     default(): T {
         return this.value;
     }
@@ -481,7 +516,7 @@ class IdentifierType extends TypeWrapper<string> {
         let id: string;
         do {
             id = DataPack.generateIdentifier();
-        } while (olmdb.get(new DataPack().write(model.constructor._primary!._cachedIndexId!).writeIdentifier(id).toUint8Array()));
+        } while (dbGet(model._txn.id, new DataPack().write(model.constructor._primary!._indexId!).writeIdentifier(id).toUint8Array()));
         return id;
     }
 }
@@ -492,33 +527,33 @@ class IdentifierType extends TypeWrapper<string> {
 */
 export class LinkType<T extends typeof Model<unknown>> extends TypeWrapper<InstanceType<T>> {
     kind = 'link';
-    TargetModel: T;
-    
+    tableName: string;
+
     /**
     * Create a new LinkType.
     * @param TargetModel - The model class this link points to.
     */
     constructor(TargetModel: T) {
         super();
-        this.TargetModel = getMockModel(TargetModel);
+        this.tableName = (TargetModel as any).tableName || TargetModel.name;
     }
     
     serialize(model: InstanceType<T>, pack: DataPack) {
-        pack.write(model._getCreatePrimaryKey());
+        pack.write(model.getPrimaryKey());
     }
     
     deserialize(pack: DataPack) {
-        return this.TargetModel._primary!.getLazy(pack.readUint8Array());
+        return modelRegistry[this.tableName]._primary!._get(currentTxn(), pack.readUint8Array(), false);
     }
     
     getError(value: InstanceType<T>) {
-        if (!(value instanceof this.TargetModel)) {
-            return new DatabaseError(`Expected instance of ${this.TargetModel.tableName}, got ${typeof value}`, 'VALUE_ERROR');
+        if (!(value instanceof modelRegistry[this.tableName])) {
+            return new DatabaseError(`Expected instance of ${this.tableName}, got ${typeof value}`, 'VALUE_ERROR');
         }
     }
     
     serializeType(pack: DataPack): void {
-        pack.write(this.TargetModel.tableName);
+        pack.write(this.tableName);
     }
     
     static deserializeType(pack: DataPack, featureFlags: number): LinkType<any> {
@@ -527,6 +562,12 @@ export class LinkType<T extends typeof Model<unknown>> extends TypeWrapper<Insta
         if (!targetModel) throw new DatabaseError(`Could not deserialize undefined model ${tableName}`, 'DESERIALIZATION_ERROR');
         return new LinkType(targetModel);
     }
+
+    toString() { return `link<${this.tableName}>`; }
+
+    getLinkedModel(): T {
+        return modelRegistry[this.tableName] as T;
+    }
 }
 
 /** Type wrapper instance for the string type. */
@@ -685,13 +726,14 @@ export function serializeType(arg: TypeWrapper<any>, pack: DataPack) {
 const TYPE_WRAPPERS: Record<string, TypeWrapper<any> | {deserializeType: (pack: DataPack, featureFlags: number) => TypeWrapper<any>}> = {
     string: string,
     number: number,
+    dateTime: dateTime,
+    boolean: boolean,
     array: ArrayType,
+    set: SetType,
     or: OrType,
     literal: LiteralType,
-    boolean: boolean,
     id: identifier,
     link: LinkType,
-    set: SetType
 };
 
 /**
@@ -703,6 +745,7 @@ const TYPE_WRAPPERS: Record<string, TypeWrapper<any> | {deserializeType: (pack:
 export function deserializeType(pack: DataPack, featureFlags: number): TypeWrapper<any> {
     const kind = pack.readString();
     const TypeWrapper = TYPE_WRAPPERS[kind];
+    if (!TypeWrapper) throw new DatabaseError(`Unknown field type in database: ${kind}`, 'CONSISTENCY_ERROR');
     if ('deserializeType' in TypeWrapper) {
         return TypeWrapper.deserializeType(pack, featureFlags);
     } else {

package/src/utils.ts

@@ -1,3 +1,5 @@
+import * as lowlevel from "olmdb/lowlevel";
+
 /**
  * Assert function for runtime checks with TypeScript assertion support.
  * @param cond - Condition to check.
@@ -10,6 +12,33 @@ export function assert(cond: any, message?: string): asserts cond {
     }
 }
 
+export function toBuffer(data: Uint8Array): ArrayBufferLike {
+    const b = data.buffer;
+    return b.byteLength === data.byteLength ? b : b.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+
+export function hashBytes(data: Uint8Array): number {
+    let a = 0x811C9DC5, b = 0x811C9DC5;
+    for (const ch of data) {
+        a = Math.imul(a ^ ch, 0x517CC1B7) >>> 0;
+        b = Math.imul(b ^ ch, 0x27220A95) >>> 0;
+    }
+    return a + ((b & 0x1FFFFF) * 0x100000000);
+}
+
+export function dbGet(txnId: number, key: Uint8Array): Uint8Array | undefined {
+    const result = lowlevel.get(txnId, toBuffer(key));
+    return result ? new Uint8Array(result) : undefined;
+}
+
+export function dbPut(txnId: number, key: Uint8Array, value: Uint8Array): void {
+    lowlevel.put(txnId, toBuffer(key), toBuffer(value));
+}
+
+export function dbDel(txnId: number, key: Uint8Array): void {
+    lowlevel.del(txnId, toBuffer(key));
+}
+
 /**
  * Regular expression for parsing error messages with paths.
  */
@@ -29,39 +58,10 @@ export function addErrorPath<T>(error: T, path: string | number): T {
     return error;
 }
 
-// Get initial log level from environment variable
-export let logLevel = parseInt(process.env.EDINBURGH_LOG_LEVEL || "0") || 0;
-
-/**
- * Global log level for debugging output.
- * 0 = no logging, 1 = model-level logs, 2 = update logs, 3 = read logs.
- */
-export function setLogLevel(level: number) {
-    logLevel = level;
-}
+// Get log level from environment variable
+// 0: no logging (default), 1: model-level logs, 2: add update logs, 3: add read logs
+export const logLevel = parseInt(process.env.EDINBURGH_LOG_LEVEL || "0") || 0;
 
 /** @internal Symbol used to access the underlying model from a proxy */
 export declare const TARGET_SYMBOL: unique symbol;
 
-export const delayedInits = new Set<{_delayedInit: () => boolean}>();
-let tryingDelayedInits = false;
-
-export function tryDelayedInits() {
-    if (tryingDelayedInits) return;
-    tryingDelayedInits = true;
-    let progress = true;
-    while(progress) {
-        progress = false;
-        for(const target of delayedInits) {
-            try {
-                if (target._delayedInit()) {
-                    delayedInits.delete(target);
-                    progress = true;
-                }
-            } catch(e) {
-                console.error("Error during delayed init:", e);
-            }
-        }
-    }
-    tryingDelayedInits = false;
-}