@ibgib/core-gib 0.0.8 → 0.0.11

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

@@ -0,0 +1,116 @@
+import { IbGibSpaceAny } from "../../../../witness/space/space-base-v1.mjs";
+import { DtoToSpaceFunction, LocalSpaceFactoryFunction } from "../metaspace-types.mjs";
+import { spaceNameIsValid } from "../../../../witness/space/space-helper.mjs";
+import { extractErrorMsg, getUUID, pretty } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { NodeFilesystemSpaceData_V1, NodeFilesystemSpaceRel8ns_V1, NodeFilesystemSpace_V1 } from "../../../../witness/space/filesystem-space/node-filesystem-space-v1.mjs";
+import { IBGIB_BASE_DIR, IBGIB_BASE_SUBPATH, IBGIB_BIN_SUBPATH, IBGIB_DNA_SUBPATH, IBGIB_ENCODING, IBGIB_IBGIBS_SUBPATH, IBGIB_META_SUBPATH } from "../../../../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 "../../../../witness/space/space-constants.mjs";
+import { getGib } 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 { InnerSpace_V1, InnerSpace_V1_Data } from "../../inner-space/inner-space-v1.mjs";
+
+
+export const fnCreateNewLocalSpace: LocalSpaceFactoryFunction = async ({
+    allowCancel,
+    spaceName,
+    getFnPrompt,
+    logalot,
+}) => {
+    const lc = `[${fnCreateNewLocalSpace.name}]`;
+    try {
+        if (logalot) { console.log(`${lc} starting... (I: a9bc8c7d54cb4bafae4c4aa515d71580)`); }
+
+        if (spaceName && !spaceNameIsValid(spaceName)) {
+            throw new Error(`spaceName (${spaceName}) is invalid.  (E: 7769ee9ed9874ff28548214efc3639c2)`);
+            // throw because this is used in RLI 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();
+        }
+
+        // ...create in memory with defaults
+        const data: InnerSpace_V1_Data = {
+            version: '1',
+            name: spaceName || ('in-memory-space_' + (await getUUID()).slice(0, 10)),
+            uuid: await getUUID(),
+            description: 'ephemeral in-memory space',
+            persistOptsAndResultIbGibs: false,
+            validateIbGibAddrsMatchIbGibs: true,
+            trace: false,
+            allowPrimitiveArgs: false,
+            catchAllErrors: true,
+            longPollingIntervalMs: DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS,
+        };
+        const newLocalSpace = new InnerSpace_V1(/*initialData*/data, /*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')}`); }
+        newLocalSpace.gib = await getGib({ ibGib: newLocalSpace, hasTjp: false });
+        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} ${error.message}`);
+        throw error;
+    } finally {
+        if (logalot) { console.log(`${lc} complete.`); }
+    }
+}
+
+export const fnDtoToSpace: DtoToSpaceFunction = async (spaceDto) => {
+    const lc = `[fnDtoToSpace]`;
+
+    try {
+        // afaict we should be dealing with the space itself in memory, so just
+        // return the reference itself.
+        if ((spaceDto as InnerSpace_V1).ibGibs) {
+            return spaceDto as InnerSpace_V1;
+        }
+
+        // it's not the reference, so make a new one? (but warn)
+        console.warn(`${lc} in memory innerspace dto that isnt' the reference to the object itself in memory? (W: b8973f3a43f546eeaf59f60331896e75)`)
+        if (!spaceDto.data) { throw new Error(`invalid spaceDto. InnerSpace_V1 should have truthy data. (E: d402fda7a6a53668b655c2885029a423)`); }
+        let space = new InnerSpace_V1(spaceDto.data as InnerSpace_V1_Data, undefined);
+        await space.initialized;
+        return space;
+    } catch (error) {
+        console.error(`${lc} ${extractErrorMsg(error)}`);
+        throw error;
+    }
+}
+
+// export const fnCreateZeroSpace: () => IbGibSpaceAny = () => {
+//     const inMemoryZeroSpace = await fnCreateNewLocalSpace({
+//         allowCancel: false,
+//         spaceName: 'in-memory-space_' + (await getUUID()).slice(0, 10),
+//         logalot,
+//     });
+//     if (!inMemoryZeroSpace) { throw new Error(`(UNEXPECTED) create inMemoryZeroSpace failed. inMemoryZeroSpace is falsy but no error? (E: 63c27616be41564377f843baa6725423)`); }
+// }
+// if (!this.fnZeroSpaceFactory) {
+// }

package/src/witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mts

@@ -0,0 +1,88 @@
+/**
+ * @module metaspace-innerspace
+ *
+ * in-memory metaspace, for running ibgib apps in memory only, where the
+ * underlying data spaces do not use persistent storage mediums.
+ */
+
+import { getUUID, } from '@ibgib/helper-gib';
+
+import { IbGibSpaceAny } from '../../../../witness/space/space-base-v1.mjs';
+import { InnerSpace_V1 } from '../../../../witness/space/inner-space/inner-space-v1.mjs';
+import { IbGibCacheService } from '../../../../common/cache/cache-types.mjs';
+import { MetaspaceFactory } from '../metaspace-types.mjs';
+import { fnCreateNewLocalSpace, fnDtoToSpace } from './metaspace-innerspace-helper.mjs';
+import { MetaspaceBase } from '../metaspace-base.mjs';
+import { GLOBAL_LOG_A_LOT, GLOBAL_TIMER_NAME } from '../../../../core-constants.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT || true;
+
+/**
+ * for use when creating a metaspace that only resides in memory, i.e.,
+ * doesn't live on a persistent backing store like a filesystem.
+ */
+export class Metaspace_Innerspace extends MetaspaceBase {
+
+  // we won't get an object back, only a DTO ibGib essentially
+  protected lc: string = `[${Metaspace_Innerspace.name}]`;
+
+  /**
+   * since this is an in-memory metaspace, we always return the same instance
+   * for the zero space.
+   */
+  private _zeroSpace: InnerSpace_V1 | undefined;
+
+  /**
+   * since this is an in-memory metaspace, we always return the same instance
+   *
+   * returns this._zeroSpace
+   */
+  get zeroSpace(): IbGibSpaceAny {
+    const lc = `${this.lc}[get zeroSpace]`;
+    if (!this._zeroSpace) { throw new Error(`${lc} this._zeroSpace falsy. should have been created on this.initialize (E: e723177fd2a74e25eb25e2299dfa4d23)`); }
+    return this._zeroSpace;
+  }
+
+  constructor(
+    protected cacheSvc: IbGibCacheService | undefined,
+  ) {
+    super(cacheSvc);
+    const lc = `${this.lc}[ctor]`;
+    if (logalot) {
+      console.log(`${lc} ${GLOBAL_TIMER_NAME}`);
+      console.timeLog(GLOBAL_TIMER_NAME);
+      console.log(`${lc} created.`);
+    }
+  }
+
+  protected async initializeMetaspaceFactory({ metaspaceFactory }: {
+    metaspaceFactory: MetaspaceFactory,
+  }): Promise<void> {
+    const lc = `[${this.initializeMetaspaceFactory.name}]`;
+    try {
+      if (logalot) { console.log(`${lc} starting... (I: 5a29670439ac47634dcdfe25225c8223)`); }
+
+      await super.initializeMetaspaceFactory({ metaspaceFactory });
+
+      metaspaceFactory.fnDefaultLocalSpaceFactory ??= (opts) => fnCreateNewLocalSpace(opts);
+      metaspaceFactory.fnDtoToSpace ??= (spaceDto) => fnDtoToSpace(spaceDto);
+
+      if (this.metaspaceFactory.fnZeroSpaceFactory) {
+        this._zeroSpace = this.metaspaceFactory.fnZeroSpaceFactory!() as InnerSpace_V1;
+      } else {
+        this._zeroSpace = await fnCreateNewLocalSpace({
+          allowCancel: false,
+          spaceName: 'in-memory-space_' + (await getUUID()).slice(0, 10),
+          logalot,
+          getFnPrompt: () => this.getFnPrompt!(),
+        }) as InnerSpace_V1;
+        if (!this._zeroSpace) { throw new Error(`(UNEXPECTED) create this._zeroSpce is falsy but no error after create? (E: 63c27616be41564377f843baa6725423)`); }
+      }
+    } catch (error) {
+      console.error(`${lc} ${error.message}`);
+      throw error;
+    } finally {
+      if (logalot) { console.log(`${lc} complete.`); }
+    }
+  }
+}