@ibgib/node-gib 0.0.2

package/src/respec-gib.node.mts

@@ -0,0 +1,201 @@
+import { readdir, open } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { statSync } from 'node:fs';
+import * as pathUtils from 'path';
+
+import { pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getGlobalRespecGib } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+// #region settings
+/**
+ * This is how I enable/disable verbose logging. Do with it what you will.
+ */
+const logalot = false;
+
+/** set this to the root of the respecs to look at */
+const RESPEC_ROOT_DIR_RELATIVE_TO_BASE = './dist';
+
+/** change this to suit your naming convention */
+const RESPEC_FILE_REG_EXP = /^.+respec\.mjs$/;
+// const RESPEC_FILE_REG_EXP = /^.*respec-gib.respec\.mjs$/;
+// if (respecPath.includes('respec-gib.respec.mjs')) {
+
+/**
+ * If on, will first load a file and see if there is an extra respecful
+ * `await respecfully`/`ifWe` block. Use these if you want to focus on a single or
+ * subset of respecs.
+ *
+ * If there are no extra respecful blocks found in an entire file, that file
+ * will be skipped.
+ *
+ * Note: this only is a flag to search through respec files.
+ */
+const LOOK_FOR_EXTRA_RESPEC = true;
+/**
+ * The names of the functions that indicate that we want to focus on just those
+ * blocks.
+ *
+ * ATOW, for first run implementation here, I am implementing it such that it
+ * will filter out files that don't have these indicators. The respec files that
+ * do have these will execute fully, but the output will only include these
+ * particular blocks.
+ */
+const EXTRA_RESPEC_FUNCTION_NAMES: string[] = ['await respecfullyDear', 'ifWeMight'];
+
+// #endregion settings
+
+// #region 1. get respec paths
+
+const basePath = process.cwd();
+const srcPath = pathUtils.join(basePath, RESPEC_ROOT_DIR_RELATIVE_TO_BASE);
+
+if (logalot) { console.log(`cwd: ${process.cwd()}`); }
+if (logalot) { console.log(`basePath: ${basePath}`); }
+if (logalot) { console.log(`srcPath: ${srcPath}`); }
+
+
+const respecGib = getGlobalRespecGib();
+const allRespecPaths = await getRespecFileFullPaths(srcPath, []);
+
+if (logalot) { console.log(`allRespecPaths: ${allRespecPaths} (I: f5182a455375a8cf2aa6e1127a082423)`); }
+let filteredRespecPaths: string[] | undefined = undefined;
+
+if (LOOK_FOR_EXTRA_RESPEC) {
+    const hasExtraRespecPromises = allRespecPaths.map(async respecPath => {
+        const hasExtra = await respecFileHasExtraRespec(respecPath);
+        return [respecPath, hasExtra] as [string, boolean];
+    });
+    const resPathHasExtraTuples = await Promise.all(hasExtraRespecPromises);
+    filteredRespecPaths = resPathHasExtraTuples
+        .filter(([_respecPath, hasExtra]) => hasExtra)
+        .map(([respecPath, _hasExtra]) => respecPath);
+
+    // if there are no files that have extra respec then we do all files
+    if (filteredRespecPaths.length === 0) {
+        if (logalot) { console.log(`filteredRespecPaths is empty. doing allRespecPaths found (I: b98f54656899646025eecb4c028ab523)`); }
+        filteredRespecPaths = allRespecPaths.concat();
+    } else {
+        console.log(`filteredRespecPaths for extra respec: ${filteredRespecPaths} (I: b98f54656899646025eecb4c028ab523)`);
+        respecGib.extraRespecOnly = true;
+    }
+}
+
+// #endregion 1. get respec paths
+
+respecGib.allRespecPaths = allRespecPaths;
+respecGib.filteredRespecPaths = filteredRespecPaths;
+const respecPaths = filteredRespecPaths ?? allRespecPaths;
+respecGib.respecPaths = respecPaths;
+if (logalot) { console.log(`respecPaths found:\n${respecPaths}`); }
+
+// #region 2. execute paths' respective respecs
+
+// for now, we'll do sequentially, but in the future we could conceivable farm
+// these out to other node processes, or at least Promise.all
+
+for (let i = 0; i < respecPaths.length; i++) {
+    const respecPath = respecPaths[i];
+    if (logalot) { console.log(respecPath); }
+    const respecPathUrl = pathToFileURL(respecPath).href;
+    const esm = await import(respecPathUrl);
+    if (logalot) { console.log(pretty(Object.keys(esm))); }
+}
+
+const skippedRespecPathCount = respecGib.allRespecPaths.length - respecGib.respecPaths.length;
+if (skippedRespecPathCount > 0) {
+    console.log('');
+    console.error('\x1b[33m%s\x1b[0m', `${skippedRespecPathCount} respec files completely skipped.`);  // yellow
+}
+if (respecGib.ifWeBlocksSkipped > 0) {
+    console.log('');
+    console.error('\x1b[33m%s\x1b[0m', `${respecGib.ifWeBlocksSkipped} ifWe blocks ran but skipped reporting`);  // yellow
+}
+
+if (respecGib.errorMsgs.length === 0) {
+    console.log('');
+    console.error('\x1b[32m%s\x1b[0m', `💚💚 nothing but respec 💚💚`);  // green
+} else {
+    console.log('');
+    console.error('\x1b[31m%s\x1b[0m', `💔💔 DISrespec found 💔💔`);  // red
+    for (const errorMsg of respecGib.errorMsgs) {
+        console.error('\x1b[31m%s\x1b[0m', errorMsg);  // red
+    }
+}
+
+// #endregion 2. execute paths' respective respecs
+
+// #region helper functions
+
+/**
+ * builds a list of respec file paths, recursively traversing subdirectories
+ * starting from `dirPath`.
+ *
+ * @param dirPath a full path corresponding to a directory
+ * @param found respec paths already found (used in recursive calls)
+ * @returns list of all respec paths according to the respec regexp constant {@link RESPEC_FILE_REG_EXP}
+ */
+async function getRespecFileFullPaths(dirPath: string, found: string[]): Promise<string[]> {
+    const lc = `[${getRespecFileFullPaths.name}][${dirPath}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: 16026290523925f79ba1933847e2a623)`); }
+        found ??= [];
+        const children = await readdir(dirPath);
+        if (logalot) { for (let i = 0; i < children.length; i++) { console.log(children[i]); } }
+        const files: string[] = [];
+        const dirs: string[] = [];
+        children.forEach(name => {
+            const fullPath = pathUtils.join(dirPath, name);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                // symbolic link could create a loop
+                if (!stat.isSymbolicLink()) { dirs.push(fullPath); }
+            } else if (!!name.match(RESPEC_FILE_REG_EXP)) {
+                files.push(fullPath);
+            }
+        });
+
+        found = found.concat(files);
+        for (let i = 0; i < dirs.length; i++) {
+            const subfound = await getRespecFileFullPaths(dirs[i], found);
+            found = found.concat(subfound);
+        }
+        return Array.from(new Set(found)); // unique
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+/**
+ * Searches through the file (without importing it) for extra respecful
+ * functions.
+ *
+ * @param respecPath
+ * @returns true if extra respecful functions found in file
+ */
+async function respecFileHasExtraRespec(respecPath: string): Promise<boolean> {
+    const lc = `[${respecFileHasExtraRespec.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: 61f3221917ba77175efa305b14defc23)`); }
+        const file = await open(respecPath);
+        for await (const line of file.readLines()) {
+            const hasExtraRespecInLine =
+                EXTRA_RESPEC_FUNCTION_NAMES.some(fnName => {
+                    if (line.includes(`${fnName}(`)) { return true; }
+                });
+            if (hasExtraRespecInLine) {
+                return true;
+            }
+        }
+        return false;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+// #endregion helper functions

package/src/spec-helper.node.respec.mts

@@ -0,0 +1,50 @@
+import { default as pathUtils } from 'path';
+
+import { delay, getUUID, } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+
+/**
+ * helper function to get the filename for use in specs.
+ *
+ * @param importMetaUrl import.meta.url
+ * @returns currently executing filename sans .respec.mjs
+ */
+export async function getCurrentFilename(importMetaUrl: string): Promise<string> {
+    const lc = `[${getCurrentFilename.name}]`;
+    try {
+        const pieces = importMetaUrl.split(pathUtils.sep);
+        let filename = pieces.at(-1)?.replace(/\.respec\.mjs$/, '')
+        if (!filename) {
+            console.warn(`filename not able to be gotten?`);
+            filename = (new Date()).toTimeString() + (await getUUID());
+        }
+        return `ibgib${pathUtils.sep}${filename}`;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+export async function specGetSpaceId(): Promise<string> {
+    await delay(10);
+    let uuid = await getUUID();
+    let now = new Date();
+    now.getMinutes();
+    let timeComponent = now.getMinutes().toString() + now.getSeconds().toString() + now.getMilliseconds().toString()
+    uuid = timeComponent + uuid.substring(timeComponent.length, uuid.length);
+    return uuid;
+}
+export function specGetSpaceName(uuid: string): string {
+    return uuid.substring(0, 8) + '-space';
+}
+
+export function specGetSpaceDescription(uuid: string): string {
+    return 'description for ' + uuid.substring(0, 8);
+}
+export function specGetBaseDir(testBaseDirRoot: string, uuid: string, logalot: boolean, lc: string): string {
+    const dir = pathUtils.join(".", testBaseDirRoot, specGetSpaceName(uuid) + "_baseDir");
+    if (logalot) { console.log(`${lc}[${specGetBaseDir.name}] dir: ${dir} (I: 410c57b7d02ac2ddf9ca32493ad19523)`); }
+    return dir;
+}
+export function specGetBaseSubPath(testBaseDirRoot: string, uuid: string, logalot: boolean, lc: string): string {
+    return "tmp";
+}

package/src/witness/space/metaspace/metaspace-nodespace/metaspace-nodespace-helper.mts

@@ -0,0 +1,290 @@
+import { extractErrorMsg, getTimestamp, getUUID, pretty } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { getGib, isPrimitive } from "@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs";
+import { GIB } from "@ibgib/ts-gib/dist/V1/constants.mjs";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+import { IbGibAddr } from "@ibgib/ts-gib/dist/types.mjs";
+import { getIbAndGib } from "@ibgib/ts-gib/dist/helper.mjs";
+import { SyncSagaInfo, SyncStatusIbGib } from "@ibgib/core-gib/dist/witness/space/outer-space/outer-space-types.mjs";
+import { SubscriptionWitness } from "@ibgib/core-gib/dist/common/pubsub/subscription/subscription-types.mjs";
+import { fnObs } from "@ibgib/core-gib/dist/common/pubsub/observer/observer-helper.mjs";
+import { ErrorIbGib_V1 } from "@ibgib/core-gib/dist/common/error/error-types.mjs";
+import { IbGibSpaceAny } from "@ibgib/core-gib/dist/witness/space/space-base-v1.mjs";
+import {
+    DtoToSpaceFunction, LocalSpaceFactoryFunction, MetaspaceService,
+} from "@ibgib/core-gib/dist/witness/space/metaspace/metaspace-types.mjs";
+import { isSpaceIb, spaceNameIsValid } from "@ibgib/core-gib/dist/witness/space/space-helper.mjs";
+import {
+    IBGIB_BASE_DIR, IBGIB_BASE_SUBPATH, IBGIB_BIN_SUBPATH,
+    IBGIB_DNA_SUBPATH, IBGIB_ENCODING, IBGIB_IBGIBS_SUBPATH, IBGIB_META_SUBPATH
+} from "@ibgib/core-gib/dist/witness/space/filesystem-space/filesystem-constants.mjs";
+import {
+    DEFAULT_LOCAL_SPACE_DESCRIPTION, DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS,
+    PERSIST_OPTS_AND_RESULTS_IBGIBS_DEFAULT
+} from "@ibgib/core-gib/dist/witness/space/space-constants.mjs";
+
+import { GLOBAL_LOG_A_LOT } from "../../../../constants.mjs";
+import { getFnPrompt } from "../../../../common/prompt-functions.mjs";
+import { NodeFilesystemSpace_V1 } from "../../node-filesystem-space/node-filesystem-space-v1.mjs";
+import { NodeFilesystemSpaceData_V1, NodeFilesystemSpaceRel8ns_V1 } from "../../node-filesystem-space/node-filesystem-space-types.mjs";
+
+/**
+ * used in verbose logging (across all ibgib libs atow)
+ */
+const logalot = GLOBAL_LOG_A_LOT;
+
+export const fnCreateNewLocalSpace: LocalSpaceFactoryFunction = async ({
+    allowCancel,
+    spaceName,
+    logalot,
+}) => {
+    const lc = `[fnCreateNewLocalSpace]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: 15bcc16f4f3f9e40e743931a3965ff22)`); }
+
+        if (spaceName && !spaceNameIsValid(spaceName)) {
+            throw new Error(`spaceName (${spaceName}) is invalid.  (E: 820b291cccf9f405f9e0cce87143e323)`);
+            // throw because this is used in RCLI and automated testing...
+        }
+        if (!spaceName) {
+
+            const promptName: () => Promise<void> = async () => {
+                const fnPrompt = getFnPrompt();
+                const resName = await fnPrompt({
+                    title: 'greetings program', msg: `all of your data is stored locally on your device's "local space".
+
+so name your space with alphanumerics & underscores, like 'phone_alice' or 'web_bob_foo', or leave blank and get a random name.
+
+Enter space name:
+`
+                });
+
+                if (resName === '' && !allowCancel) {
+                    spaceName = 'space_' + (await getUUID()).slice(0, 10);
+                } else {
+                    if (resName && spaceNameIsValid(resName)) {
+                        spaceName = resName;
+                    }
+                }
+            };
+
+            // ...prompt for name
+            await promptName();
+
+            if (!spaceName) { return undefined; /* <<<< returns early */ }
+        }
+
+        // ...create in memory with defaults
+        const newLocalSpace = new NodeFilesystemSpace_V1(/*initialData*/ {
+            version: '1',
+            uuid: await getUUID(),
+            isTjp: true,
+            timestamp: getTimestamp(),
+            name: spaceName,
+            baseDir: IBGIB_BASE_DIR,
+            spaceSubPath: spaceName,
+            baseSubPath: IBGIB_BASE_SUBPATH,
+            binSubPath: IBGIB_BIN_SUBPATH,
+            dnaSubPath: IBGIB_DNA_SUBPATH,
+            ibgibsSubPath: IBGIB_IBGIBS_SUBPATH,
+            metaSubPath: IBGIB_META_SUBPATH,
+            encoding: IBGIB_ENCODING,
+            persistOptsAndResultIbGibs: PERSIST_OPTS_AND_RESULTS_IBGIBS_DEFAULT,
+            validateIbGibAddrsMatchIbGibs: true,
+            trace: false,
+            description: DEFAULT_LOCAL_SPACE_DESCRIPTION,
+            allowPrimitiveArgs: false,
+            catchAllErrors: true,
+            longPollingIntervalMs: DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS,
+        } as NodeFilesystemSpaceData_V1, /*initialRel8ns*/ undefined);
+        if (logalot) { console.log(`${lc} localSpace.ib: ${newLocalSpace.ib}`); }
+        if (logalot) { console.log(`${lc} localSpace.gib: ${newLocalSpace.gib} (before sha256v1)`); }
+        if (logalot) { console.log(`${lc} localSpace.data: ${pretty(newLocalSpace.data || 'falsy')}`); }
+        if (logalot) { console.log(`${lc} localSpace.rel8ns: ${pretty(newLocalSpace.rel8ns || 'falsy')}`); }
+
+        // trying out with tjp, can't remember why didn't have it except for
+        // backwards compatability which i'm no longer shooting for (will be
+        // able to project old spaces to new ones i believe)
+        // newLocalSpace.gib = await getGib({ ibGib: newLocalSpace, hasTjp: false });
+        newLocalSpace.gib = await getGib({ ibGib: newLocalSpace, hasTjp: true });
+
+        if (newLocalSpace.gib === GIB) { throw new Error(`localSpace.gib not updated correctly.`); }
+        if (logalot) { console.log(`${lc} localSpace.gib: ${newLocalSpace.gib} (after sha256v1)`); }
+
+        return newLocalSpace as IbGibSpaceAny;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+export const fnDtoToSpace_nodeFilesystem: DtoToSpaceFunction = (spaceDto) => {
+    return Promise.resolve(
+        NodeFilesystemSpace_V1.createFromDto(spaceDto as IbGib_V1<NodeFilesystemSpaceData_V1, NodeFilesystemSpaceRel8ns_V1>)
+    );
+}
+
+/**
+ * wrapper around metaspace.syncIbGibs
+ * @param param0
+ * @returns
+ */
+export async function doSync_awaitAllSagas({
+    addr,
+    metaspace,
+    localSpace,
+    syncSpaces,
+    sagaReporter,
+    verbose,
+}: {
+    /**
+     * the addr whose live dependency graph is going to be built and synced.
+     */
+    addr: IbGibAddr,
+    /**
+     * it's meta yo
+     */
+    metaspace: MetaspaceService,
+    /**
+     * the space which contains the syncSpace (proxy outer space).
+     */
+    localSpace: IbGibSpaceAny,
+    /**
+     * sync space witnesses (not just ibgib dtos)
+     */
+    syncSpaces: IbGibSpaceAny[],
+    sagaReporter: (msg: string, saga: SyncSagaInfo | null) => Promise<void>,
+    /**
+     * If true, will report more in {@link sagaReporter}
+     */
+    verbose?: boolean,
+}): Promise<SyncSagaInfo[] | undefined> {
+    const lc = `[${doSync_awaitAllSagas.name}]`;
+    try {
+        if (logalot || verbose) { console.log(`${lc} starting... (I: 6110576156c3f9a946626ff299870324)`); }
+        const { ib, gib } = getIbAndGib({ ibGibAddr: addr });
+
+        if (isPrimitive({ gib })) { throw new Error(`can't sync primitive ibgib (${addr}) (E: 7f87261b5378e38d0f237afa35f52d24)`); }
+        if (isSpaceIb({ ib })) { throw new Error(`can't sync entire space ibgib (${addr}) (E: 00f8d70c4b6c7f8c3c8b26cf097ba724)`); }
+        if (syncSpaces.length === 0) { throw new Error(`syncSpaces required (E: 6015c1c2920fa5301defb91933998d24)`); }
+        if (syncSpaces.some(x => !x.witness)) { throw new Error(`(UNEXPECTED) syncSpaces.some(x => !x.witness)? sync spaces should all be witnesses (and have a witness function). these are not supposed to be just dtos (with ib, gib, data, rel8ns props). (E: 2a670f794b065576ee6df6cf22ffb324)`); }
+
+        if (verbose) { await sagaReporter('getDependencyGraph starting... (I: d20cf9d59432492ebafdc206e1ecb5dc)', null); }
+
+        const dependencyGraph = await metaspace.getDependencyGraph({
+            space: localSpace,
+            ibGibAddr: addr,
+            live: true,
+            msBetweenRetries: 1_000,
+        });
+
+        if (verbose) {
+            await sagaReporter('getDependencyGraph complete. (I: a816ca4d1612409a914661bfe97bb4d1)', null);
+            await sagaReporter('syncIbGibs spinning off... (I: 83c8502f93ee46b7ae103d8ff5fa9b42)', null);
+        }
+
+        const sagas = await metaspace.syncIbGibs({
+            dependencyGraphIbGibs: Object.values(dependencyGraph),
+            syncSpaceIbGibs: syncSpaces,
+            localSpace,
+        }) ?? [];
+        if (sagas.length === 0) { throw new Error(`(UNEXPECTED) metaspace.syncIbGibs returned undefined (no sagas)? (E: 14989ed4c654eb9419a1faaf35a3e224)`); }
+        if (verbose) {
+            await sagaReporter('syncIbGibs spin off complete. these are not yet done, it/they are just spun off and going. (I: b99dd5938064415d87a5420dc37dc1b1)', sagas.at(0) ?? null);
+        }
+
+        let sagaCount = sagas.length;
+        let sagaErrorCounter = 0;
+        /**
+         * using this during debugging...
+         */
+        const sagaErrorMsgs: string[] = [];
+        let sagaCompleteOrErrorCounter = 0;
+        let allSagasCompletePromise = new Promise<void>((resolve, reject) => {
+            const interval = setInterval(async () => {
+                if (sagaCompleteOrErrorCounter === sagaCount) {
+                    if (sagaErrorCounter > 0) {
+                        reject(`saga had errors: ${sagaErrorMsgs.join('|')} (E: 15d75f475612492e8d5d0bcf947fc72b)`);
+                    }
+                    clearInterval(interval);
+                    resolve();
+                }
+            }, 500);
+        });
+
+        const fnIncCompleteOrError = async (saga: SyncSagaInfo) => {
+            const lcInner = `${lc}[fnIncCompleteOrError]`;
+            if (logalot || verbose) { console.log(`${lcInner} starting... (I: 782b3304e67d4ebdb0acce8147a9cd9f)`); }
+            try {
+                sagaCompleteOrErrorCounter++;
+                let updateText: string;
+                if (sagaCompleteOrErrorCounter < sagaCount) {
+                    updateText = `saga (${saga.sagaId}) complete or errored. ONLY SOME (${sagaCompleteOrErrorCounter}/${sagaCount}) have completed or errored. still more to go...`;
+                } else if (sagaCompleteOrErrorCounter === sagaCount) {
+                    updateText = `saga (${saga.sagaId}) complete or errored. ALL ${sagaCount} sync sagas COMPLETE OR ERRORED.`;
+                } else {
+                    debugger; // unexpected error state. sagaCompleteOrErrorCounter > sagaCount
+                    updateText = `uhh, there is an error here. we have incremented sagaCompleteOrErrorCounter (${sagaCompleteOrErrorCounter}) to be greater than sagaCount (${sagaCount}) (E: 4d8373ee93f2466ab9e5c382ae9a3218)`;
+                }
+                if (logalot || verbose) {
+                    console.log(`${lc} ${updateText} (I: 976c3deaf7f1a592680f3364a0793524)`);
+                    await sagaReporter(`${lcInner} ${updateText}`, saga);
+                }
+            } catch (error) {
+                console.error(`${lc} ${extractErrorMsg(error)}`);
+                throw error;
+            } finally {
+                if (logalot || verbose) { console.log(`${lc}[fnIncCompleteOrError] complete. (I: 3eb96688a5880fe039445fc3d2374b24)`); }
+            }
+        };
+
+        for (let i = 0; i < sagas.length; i++) {
+            const saga = sagas[i];
+            let subscription: SubscriptionWitness = await saga.syncStatus$.subscribe(fnObs({
+                next: async (status: SyncStatusIbGib) => {
+                    // debugger; // syncStatus$ fnobs next
+                    if (logalot || verbose) {
+                        console.log(`${lc} console.dir(status)... (I: 87589e683c7be2067d3596a509deaf24)`);
+                        console.dir(status);
+                    } else {
+                        let statusCode = status.data?.statusCode;
+                        if (statusCode === "already_synced") {
+                            process.stdout.write('.');
+                        } else {
+                            console.log(statusCode);
+                        }
+                    }
+                },
+                complete: async () => {
+                    // debugger; // syncStatus$ fnobs complete before fnIncCompleteOrError
+                    if (logalot || verbose) {
+                        console.log(`${lc}[saga complete] triggered for saga (${saga.spaceId}, ${saga.multiSpaceOpId}). (I: 237a2d0db5944359b90335c83c9df60f)`);
+                    }
+                    await fnIncCompleteOrError(saga);
+                    await subscription.unsubscribe();
+                },
+                error: async (err: string | Error | ErrorIbGib_V1) => {
+                    // debugger; // syncStatus$ fnobs error before fnIncCompleteOrError
+                    const errorMsg = extractErrorMsg(err);
+                    sagaErrorMsgs.push(errorMsg);
+                    if (errorMsg.includes('EAI_AGAIN')) {
+                        console.error(`this error may be because of no internet connection. ${errorMsg}`)
+                    }
+                    console.error(`${lc}[error] err: ${errorMsg} (E: fb1b0af934354cc6b41cfe455d1ba12d)`);
+                    sagaErrorCounter++;
+                    await fnIncCompleteOrError(saga);
+                    await subscription.unsubscribe();
+                    // sagaCompleteOrErrorCounter++;
+                }
+            }));
+        }
+        await allSagasCompletePromise;
+        return sagas;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    } finally {
+        if (logalot || verbose) { console.log(`${lc} complete.`); }
+    }
+}