@stonyx/orm 0.3.2-beta.75 → 0.3.2-beta.77

package/dist/dynamodb/dynamodb-db.js

@@ -33,6 +33,23 @@ function generateUlid() {
     }
     return id;
 }
+/**
+ * Generates a monotonically unique numeric ID for DynamoDB tables with numeric keys.
+ * Uses timestamp-based generation with a sub-millisecond counter to ensure uniqueness.
+ */
+let _numericIdCounter = 0;
+let _numericIdLastMs = 0;
+function generateNumericId() {
+    const now = Date.now();
+    if (now === _numericIdLastMs) {
+        _numericIdCounter++;
+    }
+    else {
+        _numericIdLastMs = now;
+        _numericIdCounter = 0;
+    }
+    return now * 1000 + _numericIdCounter;
+}
 // ---------------------------------------------------------------------------
 // SDK Command factories (injectable for testing without real AWS SDK)
 // ---------------------------------------------------------------------------
@@ -309,10 +326,11 @@ export default class DynamoDBDB {
             return;
         const isPendingId = context.rawData?.__pendingSqlId === true;
         const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
-        // For numeric-ID models with a pending ID, generate a ULID
+        // For models with a pending ID, generate a unique replacement ID
         let finalId = record.id;
         if (isPendingId) {
-            finalId = generateUlid();
+            const keyType = this.deps.getDynamoKeyType(schema.idType);
+            finalId = keyType === 'N' ? generateNumericId() : generateUlid();
         }
         const item = this._recordToItem(record, schema, context.rawData);
         item.id = finalId;

package/dist/manage-record.js

@@ -117,9 +117,7 @@ export function createRecord(modelName, rawData = {}, userOptions = {}) {
             .finally(() => {
             // Evict non-memory records after persist to prevent unbounded heap growth (stonyx#81)
             if (store._memoryResolver && !store._memoryResolver(modelName)) {
-                const ms = store.get(modelName);
-                if (ms)
-                    ms.delete(record.id);
+                store.evictRecord(modelName, record.id);
             }
         });
     }

package/dist/store.d.ts

@@ -46,6 +46,12 @@ export default class Store {
     private _isMemoryModel;
     set(key: string, value: Map<number | string, unknown>): void;
     remove(key: string, id?: number | string): void;
+    /**
+     * Evict a record from the store with full relationship registry cleanup,
+     * WITHOUT calling record.clean(). This preserves the caller's reference
+     * to the returned record (used by memory:false post-persist eviction).
+     */
+    evictRecord(modelName: string, id: unknown): void;
     unloadRecord(model: string, id: unknown, options?: UnloadOptions): void;
     unloadAllRecords(model: string, options?: UnloadOptions): void;
     private _removeFromHasManyArrays;

package/dist/store.js

@@ -127,6 +127,26 @@ export default class Store {
             return this.unloadRecord(key, id);
         this.unloadAllRecords(key);
     }
+    /**
+     * Evict a record from the store with full relationship registry cleanup,
+     * WITHOUT calling record.clean(). This preserves the caller's reference
+     * to the returned record (used by memory:false post-persist eviction).
+     */
+    evictRecord(modelName, id) {
+        const modelStore = this.data.get(modelName);
+        if (!modelStore)
+            return;
+        if (typeof id !== 'string' && typeof id !== 'number')
+            return;
+        const raw = modelStore.get(id);
+        if (!raw || !isStoreRecord(raw))
+            return;
+        const visited = new Set([`${modelName}:${id}`]);
+        this._removeFromHasManyArrays(modelName, id, visited);
+        this._nullifyBelongsToReferences(modelName, id, visited);
+        this._cleanupRelationshipRegistries(modelName, id);
+        modelStore.delete(id);
+    }
     unloadRecord(model, id, options = {}) {
         const modelStore = this.data.get(model);
         if (!modelStore) {

package/package.json

@@ -4,7 +4,7 @@
     "stonyx-async",
     "stonyx-module"
   ],
-  "version": "0.3.2-beta.75",
+  "version": "0.3.2-beta.77",
   "description": "",
   "main": "dist/index.js",
   "type": "module",

package/src/dynamodb/dynamodb-db.ts

@@ -50,6 +50,24 @@ function generateUlid(): string {
   return id;
 }
 
+/**
+ * Generates a monotonically unique numeric ID for DynamoDB tables with numeric keys.
+ * Uses timestamp-based generation with a sub-millisecond counter to ensure uniqueness.
+ */
+let _numericIdCounter = 0;
+let _numericIdLastMs = 0;
+
+function generateNumericId(): number {
+  const now = Date.now();
+  if (now === _numericIdLastMs) {
+    _numericIdCounter++;
+  } else {
+    _numericIdLastMs = now;
+    _numericIdCounter = 0;
+  }
+  return now * 1000 + _numericIdCounter;
+}
+
 // ---------------------------------------------------------------------------
 // SDK Command factories (injectable for testing without real AWS SDK)
 // ---------------------------------------------------------------------------
@@ -459,10 +477,11 @@ export default class DynamoDBDB {
     const isPendingId = context.rawData?.__pendingSqlId === true;
     const tableName = sanitizeTableName(this.deps.getPluralName(modelName));
 
-    // For numeric-ID models with a pending ID, generate a ULID
+    // For models with a pending ID, generate a unique replacement ID
     let finalId: unknown = record.id;
     if (isPendingId) {
-      finalId = generateUlid();
+      const keyType = this.deps.getDynamoKeyType(schema.idType);
+      finalId = keyType === 'N' ? generateNumericId() : generateUlid();
     }
 
     const item = this._recordToItem(record, schema, context.rawData);

package/src/manage-record.ts

@@ -152,8 +152,7 @@ export function createRecord(modelName: string, rawData: { [key: string]: unknow
       .finally(() => {
         // Evict non-memory records after persist to prevent unbounded heap growth (stonyx#81)
         if (store._memoryResolver && !store._memoryResolver(modelName)) {
-          const ms = store.get(modelName);
-          if (ms) ms.delete(record.id as number | string);
+          store.evictRecord(modelName, record.id);
         }
       });
   }

package/src/store.ts

@@ -193,6 +193,27 @@ export default class Store {
     this.unloadAllRecords(key);
   }
 
+  /**
+   * Evict a record from the store with full relationship registry cleanup,
+   * WITHOUT calling record.clean(). This preserves the caller's reference
+   * to the returned record (used by memory:false post-persist eviction).
+   */
+  evictRecord(modelName: string, id: unknown): void {
+    const modelStore = this.data.get(modelName);
+    if (!modelStore) return;
+
+    if (typeof id !== 'string' && typeof id !== 'number') return;
+    const raw = modelStore.get(id);
+    if (!raw || !isStoreRecord(raw)) return;
+
+    const visited = new Set([`${modelName}:${id}`]);
+    this._removeFromHasManyArrays(modelName, id, visited);
+    this._nullifyBelongsToReferences(modelName, id, visited);
+    this._cleanupRelationshipRegistries(modelName, id);
+
+    modelStore.delete(id);
+  }
+
   unloadRecord(model: string, id: unknown, options: UnloadOptions = {}): void {
     const modelStore = this.data.get(model);