@ibgib/core-gib 0.1.23 → 0.1.26

package/src/sync/sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mts

@@ -2,19 +2,27 @@
  * @module SyncPeerInnerspace_V1
  */
 
-import { extractErrorMsg, unique } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { delay, extractErrorMsg, unique } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+import { IbGib_V1, IbGibData_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { isDna } from '@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
 import { IbGibSpaceAny } from '../../../witness/space/space-base-v1.mjs';
 import { SyncPeer_V1 } from '../sync-peer-v1.mjs';
-import { getFromSpace, putInSpace } from '../../../witness/space/space-helper.mjs';
+import { getFromSpace, putInSpace, registerNewIbGib } from '../../../witness/space/space-helper.mjs';
 import { SyncSagaContextIbGib_V1, } from '../../sync-saga-context/sync-saga-context-types.mjs';
 import { SyncPeerInnerspaceData_V1, SyncPeerInnerspaceIbGib_V1, SyncPeerInnerspaceOptions, SyncPeerInnerspaceRel8ns_V1 } from './sync-peer-innerspace-types.mjs';
 import { MetaspaceService } from '../../../witness/space/metaspace/metaspace-types.mjs';
 import { SyncSagaCoordinator } from '../../sync-saga-coordinator.mjs';
 import { IbGibSpaceResultData } from '../../../witness/space/space-types.mjs';
+import { InitializeSyncPeerOpts } from '../sync-peer-types.mjs';
+import { getSyncSagaMessageFromFrame } from '../../sync-saga-message/sync-saga-message-helpers.mjs';
+import { SYNC_STAGE_VALID_VALUES, SyncStage } from '../../sync-constants.mjs';
+import { SyncSagaMessageAckData_V1, SyncSagaMessageCommitData_V1, SyncSagaMessageData_V1, SyncSagaMessageDeltaData_V1, SyncSagaMessageInitData_V1 } from '../../sync-saga-message/sync-saga-message-types.mjs';
+import { getSyncSagaFrameDependencyGraph, putInSpace_dnasThenNonDnas } from '../../sync-helpers.mjs';
+import { splitPerTjpAndOrDna, toDto } from '../../../common/other/ibgib-helper.mjs';
 
 
 const logalot = GLOBAL_LOG_A_LOT || true;
@@ -22,99 +30,76 @@ const logalotControlDomain = true;
 const lcControlDomain = '[ControlDomain]';
 
 /**
- * Concrete implementation of SyncPeer for local in-memory simulation (Innerspace to Innerspace).
- * 
- * Acts as the "Network" layer, transferring data between two local spaces and 
- * executing the receiver's coordinator logic.
+ * The innerspace sync peer works with innerspaces for both sender/receiver
+ * durable/temp spaces, as well as coordinators for each.
  */
-export class SyncPeerInnerspace_V1 extends SyncPeer_V1 implements SyncPeerInnerspaceIbGib_V1 {
-
-    protected lc: string = `[${SyncPeerInnerspace_V1.name}]`;
-
+export interface InitializeSyncPeerInnerspaceOpts extends InitializeSyncPeerOpts {
+    /**
+     * specific to innerspace
+     */
+    receiverCoordinator: SyncSagaCoordinator;
     /**
      * specific to innerspace
      */
-    protected receiverCoordinator: SyncSagaCoordinator;
+    receiverMetaspace: MetaspaceService;
     /**
      * specific to innerspace
      */
-    protected receiverMetaspace: MetaspaceService;
-    public receiverSpace: IbGibSpaceAny;
-    public receiverTempSpace: IbGibSpaceAny;
+    receiverSpace: IbGibSpaceAny;
+    /**
+     * If not available at first, this will be automatically created.
+     */
+    receiverTempSpace?: IbGibSpaceAny;
+}
+
+/**
+ * Concrete implementation of SyncPeer for local in-memory simulation (Innerspace to Innerspace).
+ *
+ * Acts as the "Network" layer, transferring data between two local spaces and
+ * executing the receiver's coordinator logic.
+ */
+export class SyncPeerInnerspace_V1 extends SyncPeer_V1<InitializeSyncPeerInnerspaceOpts>
+    implements SyncPeerInnerspaceIbGib_V1 {
+
+    protected lc: string = `[${SyncPeerInnerspace_V1.name}]`;
 
     override get classname(): string {
         return SyncPeerInnerspace_V1.name;
     }
 
     constructor(
-        senderSpace: IbGibSpaceAny,
-        senderTempSpace: IbGibSpaceAny,
-        opts: SyncPeerInnerspaceOptions,
         initialData: SyncPeerInnerspaceData_V1,
         initialRel8ns?: SyncPeerInnerspaceRel8ns_V1,
     ) {
-        super(senderSpace, senderTempSpace, initialData, initialRel8ns);
-        const {
-            receiverCoordinator,
-            receiverMetaspace, receiverSpace, receiverTempSpace
-        } = opts;
-
-        this.receiverCoordinator = receiverCoordinator;
-        this.receiverMetaspace = receiverMetaspace;
-        this.receiverSpace = receiverSpace;
-        this.receiverTempSpace = receiverTempSpace;
+        super(initialData, initialRel8ns);
     }
 
     protected override async ensureReceiverTempSpace(): Promise<IbGibSpaceAny> {
-        if (!this.receiverTempSpace) {
-            const { receiverMetaspace } = this;
-
-            const uuid = crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36);
-            const tempSpaceName = `tmp_sync_recv_${uuid.substring(0, 8)}`;
-            const receiverTempSpace = await this.receiverMetaspace.createNewLocalSpace({
-                opts: {
-                    allowCancel: false,
-                    spaceName: tempSpaceName,
-                    getFnPrompt: this.receiverMetaspace.getFnPrompt!,
-                    logalot
-                }
-            });
-            if (!receiverTempSpace) { throw new Error(`(UNEXPECTED) receiverTempSpace falsy? couldn't create a temp space? (E: a6b8f86b0f58384b884a33b82924b826)`); }
-            await receiverTempSpace.initialized;
-            this.receiverTempSpace = receiverTempSpace;
-        }
-        return this.receiverTempSpace;
-    }
-
-
-    protected async push(addrs: IbGibAddr[]): Promise<void> {
-        const lc = `${this.lc}[${this.push.name}]`;
+        const lc = `${this.lc}[${this.ensureReceiverTempSpace.name}]`;
         try {
-            if (logalot) { console.log(`${lc} starting... (I: 07bce80be18f3259b8a311ed9c4da926)`); }
+            if (logalot) { console.log(`${lc} starting... (I: bab87f15dea77cd4892bd8a8d2e65826)`); }
 
-            // silly defensive checks because this has been a ridiculous development cycle
-            if (!this.senderSpace) { throw new Error(`(UNEXPECTED) this.senderSpace falsy? (E: 503e288168f5d297f4d4e028bc538826)`); }
-            if (!this.receiverSpace) { throw new Error(`(UNEXPECTED) this.receiverSpace falsy? (E: 0bd7c1a0ba4868ac7a260e15b504e826)`); }
+            if (!this.opts) { throw new Error(`(UNEXPECTED) this.opts falsy? (E: 0f85bd4c3efdbee2a829aca860c48926)`); }
 
-            await this.transfer({ addrs, from: this.senderSpace, to: this.receiverSpace });
-        } catch (error) {
-            console.error(`${lc} ${extractErrorMsg(error)}`);
-            throw error;
-        } finally {
-            if (logalot) { console.log(`${lc} complete.`); }
-        }
-    }
+            if (!this.opts.receiverTempSpace) {
+                const { receiverMetaspace } = this.opts;
 
-    protected async pull(addrs: IbGibAddr[]): Promise<void> {
-        const lc = `${this.lc}[${this.pull.name}]`;
-        try {
-            if (logalot) { console.log(`${lc} starting... (I: b16a28ed0dc8f52f1838ee257d9b1126)`); }
-
-            // silly defensive checks because this has been a ridiculous development cycle
-            if (!this.receiverSpace) { throw new Error(`(UNEXPECTED) this.receiverSpace falsy? (E: bd2fdfa89ba4c89a185b68e9bb1f1c26)`); }
-            if (!this.senderTempSpace) { throw new Error(`(UNEXPECTED) this.senderTempSpace falsy? (E: b23fa55713f881493dac4a9835ac7326)`); }
+                const uuid = crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36);
+                const tempSpaceName = `tmp_sync_recv_${uuid.substring(0, 8)}`;
+                const receiverTempSpace = await receiverMetaspace.createNewLocalSpace({
+                    opts: {
+                        allowCancel: false,
+                        spaceName: tempSpaceName,
+                        getFnPrompt: receiverMetaspace.getFnPrompt!,
+                        logalot
+                    }
+                });
+                if (!receiverTempSpace) { throw new Error(`(UNEXPECTED) receiverTempSpace falsy? couldn't create a temp space? (E: a6b8f86b0f58384b884a33b82924b826)`); }
+                await receiverTempSpace.initialized;
+                this.opts.receiverTempSpace = receiverTempSpace;
+            }
 
-            await this.transfer({ addrs, from: this.receiverSpace, to: this.senderTempSpace });
+            return this.opts.receiverTempSpace;
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;
@@ -125,20 +110,160 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 implements SyncPeerInners
 
     protected async sendContextRequest(context: SyncSagaContextIbGib_V1): Promise<SyncSagaContextIbGib_V1 | undefined> {
         const lc = `${this.lc}[${this.sendContextRequest.name}]`;
-        const { receiverSpace, receiverCoordinator, receiverMetaspace } = this;
-
         try {
+            if (!this.opts) { throw new Error(`(UNEXPECTED) this.opts falsy? (E: d8b1348e3233810128999596b1fa5826)`); }
+
+            const {
+                senderSpace, senderTempSpace,
+                receiverSpace, receiverCoordinator, receiverMetaspace,
+                receiverTempSpace
+            } = this.opts;
+
             if (logalot) { console.log(`${lc} starting...Context: ${getIbGibAddr({ ibGib: context })}`); }
 
-            // 0. Validate context (naive, not business logic validation)
+            const { sagaFrame } = context;
+
+            // The context has already been validated, authenticated and authorized at this point.
+
+            // #region sanity validation assertions
             if (!context.data) { throw new Error(`(UNEXPECTED) context.data falsy? (E: 1d2ac8a9b991d451e8900588057fe626)`); }
             if (!context.rel8ns) { throw new Error(`(UNEXPECTED) context.rel8ns falsy? (E: 3508786f0d8880bcadd346282a807826)`); }
             if (!context.rel8ns.sagaFrame) { throw new Error(`(UNEXPECTED) context.rel8ns.sagaFrame falsy? (E: ac06782ad538be406882605f0a83aa26)`); }
             if (!context.sagaFrame) { throw new Error(`(UNEXPECTED) context.sagaFrame falsy? (E: 79cd98a6d9b88a591f4596c8bc58ff26)`); }
+            if (!sagaFrame.data) { throw new Error(`(UNEXPECTED) sagaFrame.data falsy? (E: f30e290a8b770e1b387377420ea73a26)`); }
+            if (!sagaFrame.rel8ns) { throw new Error(`(UNEXPECTED) sagaFrame.rel8ns falsy? (E: f888caa698b8cf6b4893b7fd6df09726)`); }
+            if (!receiverTempSpace) { throw new Error(`(UNEXPECTED) receiverTempSpace falsy? (E: 3b46d838f6fc645c58b29215bfddb826)`); }
+            // #endregion sanity validation assertions
+
+            const { sagaIbGib: _alreadyHave, msgStones, identities } = await getSyncSagaFrameDependencyGraph({
+                sagaIbGib: sagaFrame,
+                localSpace: senderSpace,
+            });
+            if (msgStones.length !== 1) { throw new Error(`(UNEXPECTED) msgStones.length !== 1? we're only geared for a single msg stone that is always present (not 0, not greater than 1) (E: 2d3138ed130f1aca116551889483e826)`); }
+            const msg = msgStones[0];
+            if (!msg.data) { throw new Error(`(UNEXPECTED) sync saga message ibgib.data falsy? (E: 61ec18743988ad3cbab2072d1dd69826)`); }
+
+            // send the context itself, then send the payload ibgibs separately.
+            // in this innerspace, this just means putting the control ibgibs
+            // first into the receiver durable space, then we will spin off a
+            // promise to put any payload ibgibs in the receiver temp space.
+            // We'll test a little latency also, to mimic a fuller, two-part
+            // sync peer to ensure that other code is acting as expected.
+
+            // we store inside out, meaning we do the dependencies first and
+            // then the higher-level dependents.
+            const payloadIbGibsControl = [
+                ...identities, msg, sagaFrame, context
+            ].map(x => toDto({ ibGib: x }));
+            await putInSpace({
+                ibGibs: payloadIbGibsControl,
+                space: receiverSpace,
+            });
+            // register yet??
+            for (const control of payloadIbGibsControl) {
+                await registerNewIbGib({
+                    ibGib: control,
+                    space: receiverSpace,
+                    fnBroadcast: undefined
+                });
+            }
+
+            if (context.payloadIbGibsDomain && context.payloadIbGibsDomain.length > 0) {
+                await putInSpace_dnasThenNonDnas({
+                    ibGibs: context.payloadIbGibsDomain,
+                    space: receiverTempSpace,
+                });
+
+                // no need to register right now, because we're putting into the
+                // temp receiver space and we don't register until we commit
+                // const { mapWithTjp_NoDna, mapWithTjp_YesDna, mapWithoutTjps } =
+                //     splitPerTjpAndOrDna({ ibGibs: payload_NonDnas });
+            }
+
+            // at this time, the receiver has received the control ibgibs AND
+            // the payload ibgibs. so the receiver coordinator should be ready
+            // to do its thing.
+
+            const responseCtx = await receiverCoordinator.receiverContinueSync({
+                sagaContext: context,
+                metaspace: receiverMetaspace,
+                mySpace: receiverSpace,
+                myTempSpace: receiverTempSpace,
+            });
 
+            if (!responseCtx) {
+                if (logalot) { console.log(`${lc} receiver produced undefined response context. (I: 2e1888ffc9e836689d5b171887c36d26)`); }
+                return undefined; /* <<<< returns early */
+            }
+
+            // at this point, we have received the full response from the
+            // receiver coordinator. Put the response's control ibgibs in the
+            // sender's durable space (but don't register them), spin off the
+            // process of any response payloads, and return the context.
 
+            const { msgStones: msgStonesResponse, identities: identitiesResponse } =
+                await getSyncSagaFrameDependencyGraph({
+                    sagaIbGib: responseCtx.sagaFrame,
+                    localSpace: senderSpace,
+                });
+            if (msgStonesResponse.length !== 1) { throw new Error(`(UNEXPECTED) msgStonesResponse.length !== 1? we're only geared for a single msg stone that is always present (not 0, not greater than 1) (E: 2d3138ed130f1aca116551889483e826)`); }
+            const msgResponse = msgStonesResponse[0];
+            if (!msgResponse.data) { throw new Error(`(UNEXPECTED) sync saga message ibgib.data falsy? (E: 61ec18743988ad3cbab2072d1dd69826)`); }
+            const responsePayloadIbGibsControl = [
+                ...identities, msgResponse, responseCtx.sagaFrame, context
+            ].map(x => toDto({ ibGib: x }));
+            await putInSpace({
+                ibGibs: responsePayloadIbGibsControl,
+                space: senderSpace,
+            });
+            // register yet??
+            for (const control of responsePayloadIbGibsControl) {
+                await registerNewIbGib({
+                    ibGib: control,
+                    space: senderSpace,
+                    fnBroadcast: undefined
+                });
+            }
+
+            // spin off the payloads, as that may take a long time
+            const payloadIbGibsDomain_response = responseCtx.payloadIbGibsDomain;
+            if (payloadIbGibsDomain_response) {
+                new Promise<void>(async (resolve, reject) => {
+                    const lcPut = `${lc}[putPayloadsPromise]`;
+                    try {
+                        if (logalot) { console.log(`${lcPut} starting... (I: 4133e736b4c80d2cf94448b87b206826)`); }
+
+                        // 2 seconds...i want to see huge blocks of logs entries for this to see this happening
+                        const delayMs = 200;
+                        for (let i = 0; i < 10; i++) {
+                            console.warn(`${lc} ARTIFICIALLY DELAYING PAYLOADS TO MIMIC TRANSFER LATENCY. REMOVE THIS DELAY!! (W: 5e7b28f1daa82d955897e9d8cdb16f26)`)
+                            await delay(delayMs);
+                        }
+
+                        if (!senderTempSpace) { throw new Error(`(UNEXPECTED) senderTempSpace falsy? (E: b187a8f913c2295ae90d7ae2b47b6a26)`); }
+
+                        await putInSpace_dnasThenNonDnas({
+                            ibGibs: payloadIbGibsDomain_response,
+                            space: senderTempSpace,
+                        });
+
+                        if (logalot) { console.log(`${lcPut} complete.`); }
+                        resolve();
+                    } catch (error) {
+                        const errorMsg = `${lcPut} ${extractErrorMsg(error)}`;
+                        console.error(errorMsg);
+                        if (logalot) { console.log(`${lcPut} complete. (errored)`); }
+                        reject(errorMsg);
+                    }
+                }); // spin off
+
+                /**
+                 * the caller should be getting these from the observable.
+                 */
+                delete responseCtx.payloadIbGibsDomain;
+            }
 
-            throw new Error(`not implemented (E: 72840872e252d9f7380f1998b5a0c826)`);
+            return responseCtx;
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;

package/src/sync/sync-peer/sync-peer-types.mts

@@ -30,11 +30,32 @@ export interface SyncPeerRel8ns_V1 extends IbGibRel8ns_V1 {
  */
 export interface SyncPeerIbGib_V1 extends IbGib_V1<SyncPeerData_V1, SyncPeerRel8ns_V1> { }
 
+/**
+ * base initialization opts
+ */
+export interface InitializeSyncPeerOpts {
+    /**
+     * sender's durable space.
+     * 
+     * will store control ibgibs (context, sync saga ibgib, control msg stones)
+     * here (and in {@link senderTempSpace}) throughout the process for audit trail.
+     */
+    senderSpace: IbGibSpaceAny;
+    /**
+     * sender's temporary space for the entire sync transaction.
+     * 
+     * In addition to control ibgibs which are stored in both temp and durable
+     * spaces, this temp space will be where domain ibgibs are stored that are
+     * received/created throughout the transaction until commit.
+     */
+    senderTempSpace?: IbGibSpaceAny;
+}
+
 /**
  * The interface for the SyncPeer witness class.
  * It witnesses a SyncSagaContext and returns a SyncSagaContext (Request -> Response).
  */
-export interface SyncPeerWitness extends Witness_V1<
+export interface SyncPeerWitness<TInitializeOpts extends InitializeSyncPeerOpts = InitializeSyncPeerOpts> extends Witness_V1<
     SyncSagaContextData_V1,
     SyncSagaContextRel8ns_V1,
     SyncSagaContextIbGib_V1, // Input
@@ -44,23 +65,26 @@ export interface SyncPeerWitness extends Witness_V1<
     SyncPeerData_V1,
     SyncPeerRel8ns_V1
 > {
-    // witness(arg: SyncSagaContextIbGib_V1): Promise<SyncSagaContextIbGib_V1 | undefined>;
+    get classname(): string;
 
     /**
-     * sender's durable space.
+     * sender-specific opts/config
      * 
-     * will store control ibgibs (context, sync saga ibgib, control msg stones)
-     * here (and in {@link senderTempSpace}) throughout the process for audit trail.
+     * ## notes
+     * 
+     * I'm doing this hack because I have to be able to create a peer without
+     * being able to fully configure it at construction time. So I can't place
+     * this init code in the {@link initialize} method.
      */
-    senderSpace: IbGibSpaceAny;
+    opts: TInitializeOpts | undefined;
+
     /**
-     * sender's temporary space for the entire sync transaction.
+     * use this to set the senderTempSpace and any other optional opts that need
+     * to be configured just before sending any contexts across the wire.
      * 
-     * In addition to control ibgibs which are stored in both temp and durable
-     * spaces, this temp space will be where domain ibgibs are stored that are
-     * received/created throughout the transaction until commit.
+     * @see {@link opts}
      */
-    senderTempSpace: IbGibSpaceAny;
+    setOptionalOpts(arg: Partial<TInitializeOpts>): void;
 
     /**
      * Observable for streaming large domain payloads asynchronously.