@decaf-ts/for-fabric 0.1.119 → 0.2.0

package/lib/esm/contracts/ContractAdapter.js

@@ -4,16 +4,15 @@ import { FabricContractContext } from "./ContractContext.js";
 import { BadRequestError, ConflictError, InternalError, NotFoundError, onCreate, onCreateUpdate, SerializationError, } from "@decaf-ts/db-decorators";
 import { Object as FabricObject, Property, Property as FabricProperty, } from "fabric-contract-api";
 import { Logging } from "@decaf-ts/logging";
-import { PersistenceKeys, UnsupportedError, Adapter, QueryError, PagingError, MigrationError, ObserverError, AuthorizationError, ForbiddenError, ConnectionError, } from "@decaf-ts/core";
+import { PersistenceKeys, UnsupportedError, Adapter, QueryError, PagingError, MigrationError, ObserverError, AuthorizationError, ForbiddenError, ConnectionError, TransactionOperationKeys, } from "@decaf-ts/core";
 import { FabricContractRepository } from "./FabricContractRepository.js";
 import { FabricStatement } from "./FabricContractStatement.js";
 import { FabricContractSequence } from "./FabricContractSequence.js";
-import { FabricFlavour, FabricModelKeys } from "./../shared/constants.js";
+import { FabricFlavour } from "./../shared/constants.js";
 import { SimpleDeterministicSerializer } from "./../shared/SimpleDeterministicSerializer.js";
-import { Decoration, Metadata, propMetadata, } from "@decaf-ts/decoration";
+import { apply, Decoration, Metadata, propMetadata, } from "@decaf-ts/decoration";
 import { FabricContractPaginator } from "./FabricContractPaginator.js";
 import { MissingContextError } from "./../shared/errors.js";
-const MIRROR_SKIP_FLAG_PREFIX = "mirror:skip:";
 /**
  * @description Sets the creator or updater field in a model based on the user in the context
  * @summary Callback function used in decorators to automatically set the created_by or updated_by fields
@@ -96,12 +95,6 @@ export class FabricContractAdapter extends CouchDBAdapter {
      */
     static { this.textDecoder = new TextDecoder("utf8"); }
     static { this.serializer = new SimpleDeterministicSerializer(); }
-    setSequenceSegregation(seqName, fullySegregated, collections) {
-        this._sequenceSegregation.set(seqName, { fullySegregated, collections });
-    }
-    getSequenceSegregation(seqName) {
-        return this._sequenceSegregation.get(seqName);
-    }
     /**
      * @description Context constructor for this adapter
      * @summary Overrides the base Context constructor with FabricContractContext
@@ -132,17 +125,18 @@ export class FabricContractAdapter extends CouchDBAdapter {
      */
     constructor(scope, alias) {
         super(scope, FabricFlavour, alias);
-        /**
-         * @description Stores segregation metadata per sequence name
-         * @summary Needed because the Sequence creates its own context (via logCtx),
-         * losing flags set by extractSegregatedCollections on the handler context.
-         * The adapter persists across operations, making it a reliable store.
-         */
-        this._sequenceSegregation = new Map();
     }
     for(config, ...args) {
         return super.for(config, ...args);
     }
+    getModelDefaults(clazz) {
+        const m = new clazz();
+        return (Metadata.properties(clazz) || []).reduce((acc, p) => {
+            if (typeof m[p] !== "undefined")
+                acc[p] = m[p];
+            return acc;
+        }, {});
+    }
     /**
      * @description Creates a record in the state database
      * @summary Serializes a model and stores it in the Fabric state database
@@ -160,6 +154,10 @@ export class FabricContractAdapter extends CouchDBAdapter {
         const tableName = Model.tableName(clazz);
         const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
         const isMirror = ctx.getOrUndefined("mirror");
+        const segregated = isMirror
+            ? ctx.getOrUndefined("segregated")
+            : undefined;
+        const fullySegregated = ctx.isFullySegregated && !segregated;
         if (!isMirror) {
             let existing;
             try {
@@ -175,30 +173,45 @@ export class FabricContractAdapter extends CouchDBAdapter {
                 throw new ConflictError(`record with id ${id} in table ${tableName} already exists`);
         }
         try {
-            const sanitizedModel = this.normalizeForPublic(clazz, model, ctx);
             log.info(`adding entry to ${tableName} table with pk ${id}`);
-            if (ctx.isFullySegregated) {
-                await this.flushSegregatedWrites(ctx, composedKey);
-                return sanitizedModel;
+            if (segregated) {
+                // Mirror write: route the full model to the mirror collection via forPrivate
+                model = await this.forPrivate(segregated).putState(composedKey, model, ctx);
+            }
+            else {
+                const defaults = this.getModelDefaults(clazz);
+                // handle public data if not fully segregated
+                if (!fullySegregated) {
+                    if (Object.keys(model).filter((k) => {
+                        if (k === CouchDBKeys.TABLE)
+                            return false;
+                        return !(defaults &&
+                            k in defaults &&
+                            defaults[k] === model[k]);
+                    }).length)
+                        model = await this.putState(composedKey, model, ctx);
+                }
+                // handle segregated writes
+                const data = ctx.getFromChildren("segregatedData");
+                if (data) {
+                    for (const collection in data) {
+                        Object.assign(model, await this.forPrivate(collection).putState(composedKey, data[collection][id], ctx));
+                    }
+                }
             }
-            model = await this.putState(composedKey, sanitizedModel, ctx);
         }
         catch (e) {
             throw this.parseError(e);
         }
         return model;
     }
-    normalizeForPublic(clazz, model, ctx) {
-        if (model &&
-            typeof model === "object" &&
-            Object.prototype.hasOwnProperty.call(model, CouchDBKeys.TABLE)) {
-            return model;
-        }
-        const instance = Model.isModel(model)
-            ? model
-            : Model.build(model, clazz.name);
-        const prepared = this.prepare(instance, ctx);
-        return prepared.record;
+    async createAll(tableName, id, model, ...args) {
+        if (id.length !== model.length)
+            throw new InternalError("Ids and models must have the same length");
+        const { log, ctxArgs } = this.logCtx(args, this.createAll);
+        const tableLabel = Model.tableName(tableName);
+        log.debug(`Creating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...ctxArgs)));
     }
     /**
      * @description Reads a record from the state database
@@ -215,22 +228,18 @@ export class FabricContractAdapter extends CouchDBAdapter {
         const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
         let model;
         try {
-            model = await this.readState(composedKey, ctx);
+            model = ctx.isFullySegregated
+                ? {}
+                : await this.readState(composedKey, ctx);
         }
         catch (e) {
-            const fabricCtx = ctx;
-            if (e instanceof NotFoundError &&
-                (fabricCtx.isFullySegregated ||
-                    fabricCtx.getReadCollections().length ||
-                    !!ctx.getOrUndefined("segregated") ||
-                    !!ctx.getOrUndefined("mirror"))) {
-                model = {};
-            }
-            else {
-                throw this.parseError(e);
-            }
+            throw this.parseError(e);
+        }
+        const collections = ctx.getReadCollections();
+        if (collections && collections.length) {
+            for (const col of collections)
+                Object.assign(model, await this.forPrivate(col).readState(composedKey, ctx));
         }
-        model = await this.mergeSegregatedReads(ctx, composedKey, model);
         return model;
     }
     /**
@@ -246,16 +255,38 @@ export class FabricContractAdapter extends CouchDBAdapter {
     async update(clazz, id, model, ...args) {
         const { ctx, log } = this.logCtx(args, this.update);
         this.enforceMirrorAuthorization(clazz, ctx);
+        log.info(`in ADAPTER update with args ${args}`);
         const tableName = Model.tableName(clazz);
         const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
+        const isMirror = ctx.getOrUndefined("mirror");
+        const segregated = isMirror
+            ? ctx.getOrUndefined("segregated")
+            : undefined;
         try {
-            log.verbose(`updating entry to ${tableName} table with pk ${id}`);
-            const sanitizedModel = this.normalizeForPublic(clazz, model, ctx);
-            if (ctx.isFullySegregated) {
-                await this.flushSegregatedWrites(ctx, composedKey);
-                return sanitizedModel;
+            log.info(`updating entry in ${tableName} table with pk ${id}`);
+            if (segregated) {
+                // Mirror/segregated write: route the full model to the private collection
+                model = await this.forPrivate(segregated).putState(composedKey, model, ctx);
+            }
+            else {
+                const defaults = this.getModelDefaults(clazz);
+                // handle public data
+                if (Object.keys(model).filter((k) => {
+                    if (k === CouchDBKeys.TABLE)
+                        return false;
+                    return !(defaults &&
+                        k in defaults &&
+                        defaults[k] === model[k]);
+                }).length)
+                    model = await this.putState(composedKey, model, ctx);
+                // handle segregated writes
+                const data = ctx.getFromChildren("segregatedData");
+                if (data) {
+                    for (const collection in data) {
+                        Object.assign(model, await this.forPrivate(collection).putState(composedKey, data[collection][id], ctx));
+                    }
+                }
             }
-            model = await this.putState(composedKey, sanitizedModel, ctx);
         }
         catch (e) {
             throw this.parseError(e);
@@ -271,40 +302,48 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
      */
     async delete(clazz, id, ...args) {
-        const { ctx, log, ctxArgs } = this.logCtx(args, this.delete);
+        const { ctx } = this.logCtx(args, this.delete);
         this.enforceMirrorAuthorization(clazz, ctx);
         const tableName = Model.tableName(clazz);
-        const pkProp = Model.pk(clazz);
+        const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
         const isMirror = ctx.getOrUndefined("mirror");
+        const segregated = isMirror
+            ? ctx.getOrUndefined("segregated")
+            : undefined;
         let model;
-        let shouldDeletePublicState = false;
-        try {
-            const composedKey = ctx.stub.createCompositeKey(tableName, [String(id)]);
-            if (!isMirror) {
-                model = await this.read(clazz, id, ...ctxArgs);
-                shouldDeletePublicState = this.hasPublicState(model, clazz);
-            }
-            else {
-                model = { [pkProp]: id };
+        if (segregated) {
+            // Mirror/segregated delete: route through forPrivate
+            try {
+                model = await this.forPrivate(segregated).readState(composedKey, ctx);
+                await this.forPrivate(segregated).deleteState(composedKey, ctx);
             }
-            log.verbose(`deleting entry with pk ${id} from ${tableName} table`);
-            if (shouldDeletePublicState) {
-                await this.deleteState(composedKey, ctx);
+            catch (e) {
+                throw this.parseError(e);
             }
-            await this.deleteSegregatedCollections(ctx, composedKey);
         }
-        catch (e) {
-            throw this.parseError(e);
+        else {
+            try {
+                model = ctx.isFullySegregated
+                    ? {}
+                    : await this.readState(composedKey, ctx);
+                if (!ctx.isFullySegregated)
+                    await this.deleteState(composedKey, ctx);
+            }
+            catch (e) {
+                throw this.parseError(e);
+            }
+            const collections = ctx.getReadCollections();
+            if (collections && collections.length) {
+                for (const col of collections) {
+                    Object.assign(model, await this.forPrivate(col).readState(composedKey, ctx));
+                    await this.forPrivate(col).deleteState(composedKey, ctx);
+                }
+            }
         }
         return model;
     }
     async deleteState(id, context) {
-        const { ctx } = this.logCtx([context], this.deleteState);
-        const collection = ctx.getOrUndefined("segregated");
-        if (collection)
-            await ctx.stub.deletePrivateData(collection, id);
-        else
-            await ctx.stub.deleteState(id);
+        await context.stub.deleteState(id);
     }
     forPrivate(collection) {
         const toOverride = [
@@ -349,55 +388,62 @@ export class FabricContractAdapter extends CouchDBAdapter {
                             }
                             case "queryResult": {
                                 const [stub, rawInput] = argsList;
-                                return stub.getPrivateDataQueryResult(collection, rawInput);
+                                return stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput));
                             }
                             case "queryResultPaginated": {
-                                const [stub, rawInput, limit, skip] = argsList;
-                                const iterator = await stub.getPrivateDataQueryResult(collection, rawInput);
+                                const [stub, rawInput, limit, skip, bookmark] = argsList;
+                                const iterator = await stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput));
                                 const results = [];
                                 let count = 0;
-                                let reachedBookmark = skip ? false : true;
+                                const skipKey = bookmark || skip;
+                                let reachedBookmark = skipKey ? false : true;
                                 let lastKey = null;
                                 while (true) {
                                     const res = await iterator.next();
                                     if (res.value && res.value.value.toString()) {
                                         const recordKey = res.value.key;
                                         const recordValue = res.value.value.toString("utf8");
-                                        // If we have a skip, skip until we reach it
+                                        // If we have a bookmark/skip, skip until we pass it
                                         if (!reachedBookmark) {
-                                            if (recordKey === skip?.toString()) {
+                                            if (recordKey === skipKey?.toString()) {
                                                 reachedBookmark = true;
                                             }
                                             continue;
                                         }
                                         results.push({
-                                            Key: recordKey,
-                                            Record: JSON.parse(recordValue),
+                                            key: recordKey,
+                                            value: Buffer.from(recordValue),
                                         });
                                         lastKey = recordKey;
                                         count++;
                                         if (count >= limit) {
                                             await iterator.close();
-                                            return {
-                                                iterator: results,
-                                                metadata: {
-                                                    fetchedRecordsCount: results.length,
-                                                    bookmark: lastKey,
-                                                },
-                                            };
+                                            break;
                                         }
                                     }
                                     if (res.done) {
                                         await iterator.close();
-                                        return {
-                                            iterator: results,
-                                            metadata: {
-                                                fetchedRecordsCount: results.length,
-                                                bookmark: "",
-                                            },
-                                        };
+                                        break;
                                     }
                                 }
+                                // Wrap results in an async iterator compatible with resultIterator()
+                                let idx = 0;
+                                const arrayIterator = {
+                                    async next() {
+                                        if (idx < results.length) {
+                                            return { value: results[idx++], done: false };
+                                        }
+                                        return { value: undefined, done: true };
+                                    },
+                                    async close() { },
+                                };
+                                return {
+                                    iterator: arrayIterator,
+                                    metadata: {
+                                        fetchedRecordsCount: results.length,
+                                        bookmark: count >= limit ? lastKey || "" : "",
+                                    },
+                                };
                             }
                             default:
                                 throw new InternalError(`Unsupported method override ${String(prop)}`);
@@ -409,156 +455,22 @@ export class FabricContractAdapter extends CouchDBAdapter {
     }
     async putState(id, model, ctx) {
         let data;
-        const { log } = this.logCtx([ctx], this.putState);
         try {
             data = Buffer.from(FabricContractAdapter.serializer.serialize(model, false));
         }
         catch (e) {
             throw new SerializationError(`Failed to serialize record with id ${id}: ${e}`);
         }
-        const collection = ctx.getOrUndefined("segregated");
-        if (collection) {
-            if (ctx.getOrUndefined("mirror")) {
-                const cacheKey = `segregatedRecord:${collection}:${id.toString()}`;
-                let existingRecord = ctx.cache.get(cacheKey);
-                ctx.cache.remove(cacheKey);
-                if (!existingRecord) {
-                    const existing = await ctx.stub.getPrivateData(collection, id.toString());
-                    if (existing) {
-                        try {
-                            existingRecord = FabricContractAdapter.serializer.deserialize(existing.toString());
-                        }
-                        catch {
-                            existingRecord = undefined;
-                        }
-                    }
-                }
-                if (existingRecord) {
-                    const merged = Object.assign({}, existingRecord, model);
-                    data = Buffer.from(FabricContractAdapter.serializer.serialize(merged, false));
-                }
-            }
-            await ctx.stub.putPrivateData(collection, id.toString(), data);
-        }
-        else {
-            await ctx.stub.putState(id.toString(), data);
-            await this.flushSegregatedWrites(ctx, id);
-        }
-        log.silly(`state stored${collection ? ` in ${collection} collection` : ""} under id ${id}`);
-        return model;
-    }
-    async flushSegregatedWrites(ctx, compositeKey) {
-        const writeCollections = ctx.getWriteCollections();
-        if (!writeCollections.length)
-            return;
-        const writes = ctx._segregateWrite;
-        if (!writes)
-            return;
-        for (const collection of writeCollections) {
-            const entries = writes[collection];
-            if (!entries || !entries.length)
-                continue;
-            const record = this.buildSegregatedRecord(entries, collection);
-            if (!record || !Object.keys(record).length)
-                continue;
-            const cacheKey = `segregatedRecord:${collection}:${compositeKey}`;
-            ctx.cache.put(cacheKey, record);
-            const privateCtx = ctx.override({
-                segregated: collection,
-            });
-            await this.putState(compositeKey, record, privateCtx);
-        }
-        ctx.cache.remove("segregateWrite");
-    }
-    buildSegregatedRecord(entries, collection) {
-        if (!entries || !entries.length)
-            return undefined;
-        const firstModel = entries.find((entry) => !!entry.model)?.model;
-        if (!firstModel)
-            return undefined;
-        const clazz = firstModel.constructor;
-        const pkProp = Model.pk(clazz);
-        const keys = new Set();
-        entries.forEach((entry) => entry.keys.forEach((key) => keys.add(key)));
-        const metadataFields = this.getFieldsForCollection(firstModel, collection);
-        metadataFields.forEach((key) => keys.add(key));
-        if (pkProp)
-            keys.add(pkProp);
-        const record = {};
-        keys.forEach((key) => {
-            const value = entries
-                .map((entry) => entry.model[key])
-                .find((val) => typeof val !== "undefined");
-            if (typeof value === "undefined")
-                return;
-            const mappedProp = Model.columnName(clazz, key);
-            if (this.isReserved(mappedProp))
-                throw new InternalError(`Property name ${mappedProp} is reserved`);
-            record[mappedProp] =
-                value instanceof Date ? new Date(value) : value;
-        });
-        return record;
-    }
-    async mergeSegregatedReads(ctx, id, model) {
-        // Use getReadCollections which reads from the private _segregateRead property
-        const reads = ctx.getReadCollections();
-        if (!reads?.length)
-            return model;
-        for (const collection of reads) {
-            const skipFlagKey = `${MIRROR_SKIP_FLAG_PREFIX}${collection}`;
-            if (ctx.getOrUndefined(skipFlagKey))
-                continue;
-            const privateRecord = await this.readPrivateRecord(ctx, collection, id);
-            if (!privateRecord)
-                continue;
-            Object.entries(privateRecord).forEach(([key, value]) => {
-                if (typeof value === "undefined")
-                    return;
-                model[key] = value;
-            });
-        }
+        await ctx.stub.putState(id.toString(), data);
         return model;
     }
-    async readPrivateRecord(ctx, collection, id) {
-        const data = await ctx.stub.getPrivateData(collection, id);
-        if (!data)
-            return undefined;
-        const text = data.toString();
-        if (!text)
-            return undefined;
-        try {
-            return FabricContractAdapter.serializer.deserialize(text);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async deleteSegregatedCollections(ctx, id) {
-        // Use getReadCollections which reads from the private _segregateRead property
-        const reads = ctx.getReadCollections();
-        if (!reads?.length)
-            return;
-        for (const collection of reads) {
-            try {
-                await ctx.stub.deletePrivateData(collection, id);
-            }
-            catch {
-                // ignore missing private data
-            }
-        }
-    }
     async readState(id, ctx) {
         let result;
         const { log } = this.logCtx([ctx], this.readState);
-        let res;
-        const collection = ctx.get("segregated");
-        if (collection)
-            res = (await ctx.stub.getPrivateData(collection, id.toString())).toString();
-        else
-            res = (await ctx.stub.getState(id.toString())).toString();
+        const res = (await ctx.stub.getState(id.toString())).toString();
         if (!res)
-            throw new NotFoundError(`Record with id ${id}${collection ? ` in ${collection} collection` : ""} not found`);
-        log.silly(`state retrieved from${collection ? ` ${collection} collection` : ""} under id ${id}`);
+            throw new NotFoundError(`Record with id ${id} not found`);
+        log.silly(`state retrieved under id ${id}`);
         try {
             result = FabricContractAdapter.serializer.deserialize(res.toString());
         }
@@ -567,84 +479,15 @@ export class FabricContractAdapter extends CouchDBAdapter {
         }
         return result;
     }
-    async queryResult(stub, rawInput, ...args) {
-        const { ctx } = this.logCtx(args, this.queryResult);
-        let res;
-        const collection = ctx.get("segregated");
-        if (collection)
-            res = await ctx.stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput));
-        else
-            res = await stub.getQueryResult(JSON.stringify(rawInput));
-        return res;
-    }
-    createRowsIterator(rows) {
-        let index = 0;
-        return {
-            // @ts-expect-error typeing of iterator?
-            async next() {
-                if (index < rows.length) {
-                    const row = rows[index++];
-                    return {
-                        value: { key: row.key, value: row.value },
-                        done: false,
-                    };
-                }
-                return { done: true };
-            },
-            async close() {
-                // noop
-            },
-        };
-    }
-    async queryResultPaginated(stub, rawInput, limit = 250, page, bookmark, ...args) {
-        const { ctx } = this.logCtx(args, this.readState);
-        let res;
-        const collection = ctx.get("segregated");
-        if (collection) {
-            const clonedInput = JSON.parse(JSON.stringify(rawInput));
-            clonedInput.selector = clonedInput.selector || {};
-            if (bookmark)
-                clonedInput.selector._id = { $gt: bookmark.toString() };
-            const limitValue = typeof limit === "number" && limit > 0 ? limit : Number.MAX_VALUE;
-            const iterator = await stub.getPrivateDataQueryResult(collection, JSON.stringify(clonedInput));
-            const rows = [];
-            let lastKey = "";
-            while (rows.length < limitValue) {
-                const resRow = await iterator.next();
-                if (resRow.done)
-                    break;
-                if (resRow.value && resRow.value.value) {
-                    rows.push({
-                        key: resRow.value.key,
-                        value: resRow.value.value,
-                    });
-                    lastKey = resRow.value.key;
-                }
-            }
-            await iterator.close();
-            res = {
-                iterator: this.createRowsIterator(rows),
-                metadata: {
-                    fetchedRecordsCount: rows.length,
-                    bookmark: rows.length ? lastKey : "",
-                },
-            };
-        }
-        else
-            res = await stub.getQueryResultWithPagination(JSON.stringify(rawInput), limit, bookmark?.toString());
-        return res;
+    async queryResult(stub, rawInput, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return stub.getQueryResult(JSON.stringify(rawInput));
     }
-    mergeModels(results) {
-        const extract = (model) => Object.entries(model).reduce((accum, [key, val]) => {
-            if (typeof val !== "undefined")
-                accum[key] = val;
-            return accum;
-        }, {});
-        let finalModel = results.pop();
-        for (const res of results) {
-            finalModel = Object.assign({}, extract(finalModel), extract(res));
-        }
-        return finalModel;
+    async queryResultPaginated(stub, rawInput, limit = 250, page, bookmark, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return stub.getQueryResultWithPagination(JSON.stringify(rawInput), limit, bookmark?.toString());
     }
     /**
      * @description Decodes binary data to string
@@ -669,6 +512,7 @@ export class FabricContractAdapter extends CouchDBAdapter {
         let baseFlags = Object.assign({
             segregated: false,
             rebuildWithTransient: false,
+            fullySegregated: false,
         }, flags);
         const stubFromFlags = flags.stub || flags.stub;
         const identityFromFlags = flags.identity ||
@@ -793,15 +637,16 @@ export class FabricContractAdapter extends CouchDBAdapter {
      *   FabricContractAdapter-->>Caller: results
      */
     async raw(rawInput, docsOnly = true, ...args) {
-        const { log, ctx } = this.logCtx(args, this.raw);
+        const { log, ctx, ctxArgs } = this.logCtx(args, this.raw);
+        const enableSegregates = !args.length || args[0] !== true;
         const { skip, limit } = rawInput;
         let iterator;
-        const resp = { docs: [], bookmark: undefined };
+        let resp = { docs: [], bookmark: undefined };
         if (limit || skip) {
             delete rawInput["limit"];
             delete rawInput["skip"];
             log.debug(`Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`);
-            const response = (await this.queryResultPaginated(ctx.stub, rawInput, limit || Number.MAX_VALUE, skip?.toString(), rawInput["bookmark"], ctx));
+            const response = (await this.queryResultPaginated(ctx.stub, rawInput, limit || Number.MAX_VALUE, skip?.toString(), rawInput["bookmark"], ...[ctx]));
             resp.bookmark = response.metadata.bookmark;
             iterator = response.iterator;
         }
@@ -812,8 +657,30 @@ export class FabricContractAdapter extends CouchDBAdapter {
         log.debug("Iterator acquired");
         resp.docs = (await this.resultIterator(log, iterator));
         log.debug(`returning ${Array.isArray(resp.docs) ? resp.docs.length : 1} results`);
-        if (docsOnly)
+        const collections = enableSegregates ? ctx.getReadCollections() : undefined;
+        const segregated = [];
+        if (collections && collections.length) {
+            // Restore limit/skip for segregated queries (they were removed above)
+            const segregatedInput = { ...rawInput };
+            if (limit)
+                segregatedInput.limit = limit;
+            if (skip)
+                segregatedInput.skip = skip;
+            for (const collection of collections) {
+                segregated.push(await this.forPrivate(collection).raw(segregatedInput, false, true, ...ctxArgs));
+            }
+            // choose the response with the most results
+            resp = segregated.reduce((acc, curr) => {
+                if (!acc)
+                    return curr;
+                if (curr.docs && curr.docs.length >= acc?.docs.length)
+                    return curr;
+                return acc;
+            }, resp);
+        }
+        if (docsOnly) {
             return resp.docs;
+        }
         return resp;
     }
     async view(
@@ -830,14 +697,6 @@ export class FabricContractAdapter extends CouchDBAdapter {
     Statement() {
         return new FabricStatement(this);
     }
-    async createAll(tableName, id, model, ...args) {
-        if (id.length !== model.length)
-            throw new InternalError("Ids and models must have the same length");
-        const { log, ctxArgs } = this.logCtx(args, this.createAll);
-        const tableLabel = Model.tableName(tableName);
-        log.debug(`Creating ${id.length} entries ${tableLabel} table`);
-        return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...ctxArgs)));
-    }
     async updateAll(tableName, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
@@ -854,115 +713,98 @@ export class FabricContractAdapter extends CouchDBAdapter {
      */
     prepare(model, ...args) {
         const { log, ctx } = this.logCtx(args, this.prepare);
+        const split = Model.segregate(model);
         const tableName = Model.tableName(model.constructor);
         const pk = Model.pk(model.constructor);
-        const collection = ctx.getOrUndefined("segregated");
+        const id = model[pk];
         const isMirror = ctx.getOrUndefined("mirror");
-        let entries;
-        if (collection && isMirror) {
-            // MIRROR mode: keep ALL properties (full model copy)
-            entries = Object.keys(model)
-                .map((key) => [key, model[key]])
-                .filter(([, val]) => typeof val !== "undefined");
-        }
-        else if (collection) {
-            // SEGREGATED mode: keep only properties decorated for this collection + pk
-            const collectionFields = this.getFieldsForCollection(model, collection);
-            entries = [...new Set([pk, ...collectionFields])]
-                .map((key) => [key, model[key]])
-                .filter(([, val]) => typeof val !== "undefined");
-        }
-        else {
-            // NORMAL mode: strip transient (current behavior)
-            const split = Model.segregate(model);
-            entries = Object.entries(split.model).filter(([, val]) => typeof val !== "undefined");
-        }
-        const record = entries.reduce((accum, [key, val]) => {
-            const mappedProp = Model.columnName(model, key);
-            if (this.isReserved(mappedProp))
-                throw new InternalError(`Property name ${mappedProp} is reserved`);
-            val = val instanceof Date ? new Date(val) : val;
-            accum[mappedProp] = val;
-            return accum;
-        }, {});
-        // Add table identifier
-        record[CouchDBKeys.TABLE] = tableName;
+        const mapToRecord = function (obj, keysOverride) {
+            if (keysOverride)
+                keysOverride = [...new Set([...keysOverride, pk])];
+            const result = Object.entries(obj).reduce((accum, [key, val]) => {
+                if (typeof val === "undefined")
+                    return accum;
+                if (keysOverride && !keysOverride.includes(key))
+                    return accum;
+                const mappedProp = Model.columnName(model, key);
+                if (this.isReserved(mappedProp))
+                    throw new InternalError(`Property name ${mappedProp} is reserved`);
+                val = val instanceof Date ? new Date(val) : val;
+                accum[mappedProp] = val;
+                return accum;
+            }, {});
+            if (Object.keys(result).filter((k) => Boolean(result[k])).length) {
+                // Add table identifier
+                result[CouchDBKeys.TABLE] = tableName;
+            }
+            return result;
+        }.bind(this);
         log.silly(`Preparing record for ${tableName} table with pk ${model[pk]}`);
+        const segregatedWriteKeys = ctx.getSegregatedWrites();
+        const segregatedWrites = {};
+        if (segregatedWriteKeys) {
+            for (const collection in segregatedWriteKeys) {
+                segregatedWrites[collection] = segregatedWrites[collection] || {};
+                segregatedWrites[collection][id] = mapToRecord(ctx.getOrUndefined("forceSegregateWrite")
+                    ? split.model
+                    : split.transient, segregatedWriteKeys[collection]);
+            }
+        }
+        // In mirror mode, the record should contain ALL model properties (full copy)
+        const record = isMirror ? mapToRecord(model) : mapToRecord(split.model);
         return {
             record,
             id: model[pk],
-            transient: collection ? undefined : Model.segregate(model).transient,
+            transient: !isMirror && split.transient && Object.keys(split.transient).length
+                ? mapToRecord(split.transient)
+                : undefined,
+            segregated: isMirror ? undefined : segregatedWrites,
         };
     }
-    /**
-     * @description Gets the property names that belong to a specific private/shared collection
-     * @summary Looks up per-property metadata set by @privateData/@sharedData decorators
-     * to determine which properties are decorated for the given collection name.
-     */
-    getFieldsForCollection(model, collection) {
-        const constr = model.constructor;
-        const properties = Metadata.validatableProperties(constr);
-        if (!properties)
-            return [];
-        return properties.filter((prop) => {
-            const privateKey = Metadata.key(FabricModelKeys.PRIVATE, prop);
-            const privateMeta = Metadata.get(constr, privateKey);
-            if (privateMeta?.collections?.includes(collection))
-                return true;
-            const sharedKey = Metadata.key(FabricModelKeys.SHARED, prop);
-            const sharedMeta = Metadata.get(constr, sharedKey);
-            if (sharedMeta?.collections?.includes(collection))
-                return true;
-            return false;
-        });
-    }
     revert(obj, clazz, id, transient, ...args) {
         const { log, ctx } = this.logCtx(args, this.revert);
         const ob = {};
         const pk = Model.pk(clazz);
+        const pkProps = Model.pkProps(clazz);
+        if (pkProps?.type === Number && typeof id === "string") {
+            id = Number(id);
+        }
         ob[pk] = id;
-        const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
-        log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
-        const result = Object.keys(m).reduce((accum, key) => {
-            accum[key] =
-                obj[Model.columnName(accum, key)];
-            return accum;
-        }, m);
-        if (transient &&
-            this.shouldRebuildWithTransient(ctx, ctx.getOrUndefined("operation"))) {
-            log.debug(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
-            Object.entries(transient).forEach(([key, val]) => {
-                if (key in result && result[key] !== undefined)
-                    log.warn(`overwriting existing ${key}. if this is not a default value, this may pose a problem`);
-                result[key] = val;
-            });
+        log.silly(`Rebuilding model ${clazz.name} id ${id}`);
+        function mapToModel(r) {
+            const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
+            const attributes = Model.getAttributes(clazz);
+            const keys = attributes.length ? attributes : Object.keys(m);
+            return keys
+                .filter((k) => k !== pk)
+                .reduce((accum, key) => {
+                accum[key] =
+                    r[Model.columnName(accum, key)];
+                return accum;
+            }, m);
+        }
+        let result = mapToModel(obj);
+        if (transient && !this.shouldRebuildWithTransient(ctx)) {
+            log.debug(`filtering transient properties: ${Object.keys(transient).join(", ")}`);
+            result = Object.entries(result).reduce((acc, [key, v]) => {
+                if (key === pk || !(key in transient)) {
+                    acc[key] = v;
+                }
+                return acc;
+            }, new clazz());
         }
         return result;
     }
-    shouldRebuildWithTransient(ctx, operation) {
+    shouldRebuildWithTransient(ctx) {
         if (!ctx)
             return false;
         if (ctx.getOrUndefined("rebuildWithTransient"))
             return true;
+        const operation = ctx.getOrUndefined("operation");
         if (!operation)
-            return false;
+            return true;
         const op = operation.toString().toLowerCase();
-        return (op.includes("read") ||
-            op.includes("find") ||
-            op.includes("query") ||
-            op.includes("statement") ||
-            op.includes("page"));
-    }
-    hasPublicState(model, clazz) {
-        if (!model)
-            return false;
-        const instance = Model.isModel(model)
-            ? model
-            : Model.build(model, clazz.name);
-        const split = Model.segregate(instance);
-        const pkProp = Model.pk(clazz);
-        return Object.keys(split.model).some((key) => key !== pkProp &&
-            typeof split.model[key] !== "undefined");
+        return !TransactionOperationKeys.map((k) => k.toLowerCase()).includes(op);
     }
     getContextMsp(context) {
         const identity = context.get("identity");
@@ -1095,11 +937,19 @@ export class FabricContractAdapter extends CouchDBAdapter {
         super.decoration();
         Decoration.flavouredAs(FabricFlavour)
             .for(PersistenceKeys.CREATED_BY)
-            .define(onCreate(createdByOnFabricCreateUpdate), propMetadata(PersistenceKeys.CREATED_BY, {}))
+            .define({
+            decorator: function createdBy() {
+                return apply(onCreate(createdByOnFabricCreateUpdate), propMetadata(PersistenceKeys.CREATED_BY, {}));
+            },
+        })
             .apply();
         Decoration.flavouredAs(FabricFlavour)
             .for(PersistenceKeys.UPDATED_BY)
-            .define(onCreateUpdate(createdByOnFabricCreateUpdate), propMetadata(PersistenceKeys.UPDATED_BY, {}))
+            .define({
+            decorator: function createdBy() {
+                return apply(onCreateUpdate(createdByOnFabricCreateUpdate), propMetadata(PersistenceKeys.UPDATED_BY, {}));
+            },
+        })
             .apply();
         Decoration.flavouredAs(FabricFlavour)
             .for(PersistenceKeys.COLUMN)