@ibgib/core-gib 0.0.4

package/src/witness/space/bootstrap/bootstrap-constants.mts

@@ -0,0 +1,15 @@
+import { GIB } from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+/**
+ * See {@link BootstrapIbGib}
+ */
+export const BOOTSTRAP_IBGIB_ADDR = `bootstrap^${GIB}`;
+/**
+ * {@see BootstrapData}
+ */
+export const BOOTSTRAP_DATA_DEFAULT_SPACE_ID_KEY = `defaultSpaceId`;
+/**
+ * Key for index tracking known spaceIds in a bootstrap ibgib.
+ * {@see BootstrapData}
+ */
+export const BOOTSTRAP_DATA_KNOWN_SPACE_IDS_KEY = `spaceIds`;

package/src/witness/space/inner-space-v1.ts

@@ -0,0 +1,372 @@
+import { getIbGibAddr, IbGibAddr } from '@ibgib/ts-gib';
+import {
+    IbGib_V1, IbGibRel8ns_V1, IbGibData_V1, sha256v1, Factory_V1, ROOT,
+} from '@ibgib/ts-gib/dist/V1/index.mjs';
+
+
+import { SpaceBase_V1 } from './space-base-v1.mjs';
+import {
+    IbGibSpaceData, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns,
+    IbGibSpaceOptionsIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns,
+    IbGibSpaceResultIbGib
+} from './space-types.mjs';
+import { getSpaceIb } from './space-helper.mjs';
+import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
+import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
+
+const logalot = GLOBAL_LOG_A_LOT || false;
+
+export interface InnerSpace_V1_Data extends IbGibSpaceData {
+    // /**
+    //  * If true, then this will include this space's ibGib's addrs (i.e. index)
+    //  * in its {@link data} property.
+    //  */
+    // trackAddrs: boolean;
+}
+
+/**
+ * Base class convenience for a "local" space
+ * (i.e. analogous to residing on the same computer as the app).
+ *
+ * Base implementation defaults to a naive in-memory internal object that
+ * tracks ibgibs.
+ */
+export class InnerSpace_V1<
+    TIbGib extends IbGib_V1 = IbGib_V1,
+    TData extends InnerSpace_V1_Data = InnerSpace_V1_Data,
+    TRel8ns extends IbGibRel8ns_V1 = IbGibRel8ns_V1
+> extends SpaceBase_V1<
+    TIbGib,
+    IbGibSpaceOptionsData,
+    IbGibSpaceOptionsRel8ns,
+    IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>,
+    IbGibSpaceResultData,
+    IbGibSpaceResultRel8ns,
+    IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>,
+    TData,
+    TRel8ns
+> {
+
+    /**
+     * Log context for convenience with logging. (Ignore if you don't want to use this.)
+     */
+    protected lc: string = `[${InnerSpace_V1.name}]`;
+
+    /**
+     * In-memory store of ibgibs stored in this inner space object.
+     *
+     * @see {@link rel8ns} in {@link WitnessBase_V1} base class.
+     */
+    ibGibs: { [key: string]: TIbGib } = {};
+
+
+
+    constructor(
+        // I have this following commented out. I copied over some of this behavior from the keystone lib
+        // and I'm not sure what I'm keeping here.
+        // NOTE: (I refactored the name "repo" to "space" because it seemed to fit better.)
+        // /**
+        //  * Default predicate value when putting an unknown ibGib.
+        //  *
+        //  * ## notes
+        //  *
+        //  * So when a repo witnesses another ibGib, it either defaults to
+        //  * storing that ibGib or not storing that ibGib. This is what that
+        //  * is referring to. If it's optimistic, then it stores any ibGib by
+        //  * default and it passes its put predicate.
+        //  */
+        // public optimisticPut: boolean = true,
+        initialData: TData,
+        initialRel8ns: TRel8ns,
+    ) {
+        super(initialData, initialRel8ns);
+
+        const lc = `${this.lc}[ctor]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            this.initialize();
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+        this.ib = `witness space ${InnerSpace_V1.name}`;
+        this.ib = getSpaceIb({ space: this, classname: InnerSpace_V1.name });
+    }
+
+    /**
+     * Initializes to default space values.
+     */
+    protected initialize(): void {
+        const lc = `${this.lc}[${this.initialize.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            // if (!this.data) { this.data = h.clone(DEFAULT_IONIC_SPACE_DATA_V1); }
+            // if (!this.data.baseDir) { this.data.baseDir = IBGIB_BASE_DIR; }
+
+            this.ib = getSpaceIb({ space: this, classname: InnerSpace_V1.name });
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
+    protected async getImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.get.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            const { ibGibAddrs } = arg.data!;
+            if (!ibGibAddrs) { throw new Error(`(UNEXPECTED) arg.data.ibGibAddrs falsy? (E: 33dcc212788221c601bf2258eb1cd523)`); }
+            const resultIbGibs: TIbGib[] = [];
+            let notFoundIbGibAddrs: IbGibAddr[] | undefined = undefined;
+            for (let i = 0; i < ibGibAddrs.length; i++) {
+                const addr = ibGibAddrs[i];
+                if (Object.keys(this.ibGibs).includes(addr)) {
+                    resultIbGibs.push(this.ibGibs[addr]);
+                } else {
+                    if (!notFoundIbGibAddrs) { notFoundIbGibAddrs = []; }
+                    notFoundIbGibAddrs.push(addr);
+                }
+            }
+            if (notFoundIbGibAddrs && notFoundIbGibAddrs.length > 0) {
+                resultData.addrsNotFound = notFoundIbGibAddrs;
+                resultData.success = false;
+            }
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+        }
+        const result = await this.resulty({ resultData });
+        return result;
+    }
+    protected async putImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.put.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            const ibGibs = arg.ibGibs || [];
+            const addrsAlreadyHave: IbGibAddr[] = [];
+
+            await this.putIbGibsImpl({ ibGibs, addrsAlreadyHave });
+
+            if (addrsAlreadyHave.length > 0) {
+                resultData.addrsAlreadyHave = addrsAlreadyHave;
+                resultData.warnings = (resultData.warnings || []).concat([`${lc} already had addr(s).`]);
+            }
+            resultData.success = true;
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+            resultData.success = false;
+        }
+        const result = await this.resulty({ resultData });
+        return result;
+    }
+    protected async putIbGibsImpl({
+        ibGibs,
+        addrsAlreadyHave,
+    }: {
+        ibGibs: TIbGib[],
+        addrsAlreadyHave: IbGibAddr[],
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.putIbGibsImpl.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting...`); }
+            if (!ibGibs) { throw new Error(`ibGibs required. (E: cd479b15097d45a5bf0c8ca13c9f3487)`); }
+            if (!addrsAlreadyHave) { throw new Error(`addrsAlreadyHave required. (E: 18b2c8eef27bc267c55755e272367e22)`); }
+
+            for (let i = 0; i < ibGibs?.length; i++) {
+                const ibGib = ibGibs[i];
+                const addr = getIbGibAddr({ ibGib });
+                if (!Object.keys(this.ibGibs).includes(addr)) {
+                    this.ibGibs[addr] = ibGib;
+                } else {
+                    addrsAlreadyHave.push(addr);
+                }
+            }
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+
+    }
+
+    protected async deleteImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.delete.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            const addrsNotFound: IbGibAddr[] = [];
+            const addrsDeleted: IbGibAddr[] = [];
+            const ibGibAddrs = arg.data!.ibGibAddrs || [];
+            for (let i = 0; i < ibGibAddrs.length; i++) {
+                const addr = ibGibAddrs[i];
+                if (Object.keys(this.ibGibs).includes(addr)) {
+                    delete this.ibGibs[addr];
+                    addrsDeleted.push(addr);
+                } else {
+                    addrsNotFound.push(addr);
+                }
+            }
+            if (addrsNotFound.length > 0) {
+                resultData.addrsNotFound = addrsNotFound.concat();
+                const warningMsg = `${lc} some addrs (${addrsNotFound.length}) not found: ${addrsNotFound}`;
+                resultData.warnings = (resultData.warnings || []).concat([warningMsg]);
+            }
+            resultData.success = true;
+            resultData.addrs = addrsDeleted.concat();
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+            resultData.success = false;
+        }
+        try {
+            const result = await this.resulty({ resultData });
+            return result;
+        } catch (error) {
+            console.error(`${lc} error forming result ibGib. error: ${error.message}`);
+            throw error;
+        }
+    }
+    protected async getAddrsImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.getAddrs.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            resultData.addrs = Object.keys(this.ibGibs).concat();
+            resultData.success = true;
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+            resultData.success = false;
+        }
+        const result = await this.resulty({ resultData });
+        return result;
+    }
+    /**
+     * Performs a naive `exists: boolean` or `includes: boolean` analog.
+     *
+     * If all of the addresses are found, will result in `success` and `can` being `true`.
+     *
+     * Else, `can` will be falsy, and `addrsNotFound` will be populated with all/some of
+     * the queried addresses.
+     *
+     * ## notes
+     *
+     * This does not take authorization into account in any way. it's a simple, naive in-memory
+     * storage ibGib witness.
+     *
+     * @returns result ibGib whose primary value is `can`
+     */
+    protected async canGetImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.canGet.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            const { ibGibAddrs } = arg.data!;
+            if (!ibGibAddrs) { throw new Error(`(UNEXPECTED) arg.data.ibGibAddrs falsy? (E: d94c64744037ca443589fca71e121123)`); }
+            let notFoundIbGibAddrs: IbGibAddr[] | undefined = undefined;
+            for (let i = 0; i < ibGibAddrs.length; i++) {
+                const addr = ibGibAddrs[i];
+                if (!Object.keys(this.ibGibs).includes(addr)) {
+                    if (!notFoundIbGibAddrs) { notFoundIbGibAddrs = []; }
+                    notFoundIbGibAddrs.push(addr);
+                }
+            }
+            resultData.success = true;
+            if (notFoundIbGibAddrs && notFoundIbGibAddrs.length > 0) {
+                resultData.addrsNotFound = notFoundIbGibAddrs;
+                resultData.can = false;
+            } else {
+                resultData.can = true;
+            }
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+        }
+        const result = await this.resulty({ resultData });
+        return result;
+    }
+    protected async canPutImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.canPut.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            const ibGibs = arg.ibGibs || [];
+            const addrsAlreadyHave: IbGibAddr[] = [];
+            for (let i = 0; i < ibGibs?.length; i++) {
+                const ibGib = ibGibs[i];
+                const addr = getIbGibAddr({ ibGib });
+                if (Object.keys(this.ibGibs).includes(addr)) {
+                    addrsAlreadyHave.push(addr);
+                }
+            }
+            resultData.success = true;
+            if (addrsAlreadyHave.length > 0) {
+                resultData.addrsAlreadyHave = addrsAlreadyHave;
+                resultData.warnings = (resultData.warnings || []).concat([`${lc} already have addr(s).`]);
+            }
+            resultData.can = ibGibs.length > addrsAlreadyHave.length;
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+        }
+        const result = await this.resulty({ resultData });
+        return result;
+    }
+
+    protected async canDeleteImpl(arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>):
+        Promise<IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>> {
+        const lc = `${this.lc}[${this.canDeleteImpl.name}]`;
+        const resultData: IbGibSpaceResultData = { optsAddr: getIbGibAddr({ ibGib: arg }), }
+        try {
+            throw new Error('not implemented');
+        } catch (error) {
+            console.error(`${lc} error: ${error.message}`);
+            resultData.errors = [error.message];
+            resultData.success = false;
+        }
+        try {
+            const result = await this.resulty({ resultData });
+            return result;
+        } catch (error) {
+            console.error(`${lc} error forming result ibGib. error: ${error.message}`);
+            throw error;
+        }
+    }
+    protected async persistOptsAndResultIbGibs({
+        arg,
+        result
+    }: {
+        arg: IbGibSpaceOptionsIbGib<TIbGib, IbGibSpaceOptionsData, IbGibSpaceOptionsRel8ns>,
+        result: IbGibSpaceResultIbGib<TIbGib, IbGibSpaceResultData, IbGibSpaceResultRel8ns>,
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.persistOptsAndResultIbGibs.name}]`;
+        try {
+            if (logalot || this.data?.trace) { console.log(`${lc} starting...`); }
+            if (logalot || this.data?.trace) {
+                console.log(`${lc} doing arg?.data?.cmd: ${arg?.data?.cmd}, result?.data?.success: ${result?.data?.success}`);
+            }
+            let argValidationErrors = await validateIbGibIntrinsically({ ibGib: arg });
+            if (argValidationErrors && argValidationErrors.length > 0) { throw new Error(`invalid arg. cannot persist. (E: 015d38de71a3407f9d77fc4ed3404bf0)`); }
+            let resultValidationErrors = result ?
+                await validateIbGibIntrinsically({ ibGib: result }) :
+                null;
+            if (resultValidationErrors && resultValidationErrors.length > 0) { throw new Error(`invalid arg. cannot persist. (E: 015d38de71a3407f9d77fc4ed3404bf0)`); }
+
+            const ibGibs = [arg, result ?? ROOT];
+            await this.putIbGibsImpl({ ibGibs: <any[]>ibGibs, addrsAlreadyHave: [] });
+        } catch (error) {
+            console.error(`${lc} ${error.message}`);
+            // this is a best effort storage, so we do not rethrow
+            // throw error;
+        } finally {
+            if (logalot || this.data?.trace) { console.log(`${lc} complete.`); }
+        }
+    }
+}

package/src/witness/space/outer-space/outer-space-constants.mts

@@ -0,0 +1 @@
+export const OUTER_SPACE_DEFAULT_IB_DELIMITER = ' ';

package/src/witness/space/outer-space/outer-space-helper.mts

@@ -0,0 +1,91 @@
+/**
+ * @module outer-space
+ * Outer spaces are spaces connecting local inner spaces.
+ * ATOW there is just sync spaces, but definitely just the beginning.
+ *
+ * ## on future implementations, CRDT-like behavior
+ *
+ * I just realized that when merging, I can actually create a meta transform
+ * ibgib to maintain the order of transforms.
+ */
+
+import { Ib, } from '@ibgib/ts-gib';
+
+import {
+    OuterSpaceSubtype, OuterSpaceType,
+    StatusCode, StatusIbInfo,
+    VALID_OUTER_SPACE_SUBTYPES, VALID_OUTER_SPACE_TYPES,
+} from './outer-space-types.mjs';
+import { OUTER_SPACE_DEFAULT_IB_DELIMITER } from './outer-space-constants.mjs';
+
+
+/**
+ * Composes ib with given params info.
+ *
+ * @returns ib string with given info encoded
+ */
+export function getStatusIb({
+    sagaId,
+    statusCode,
+    spaceType,
+    spaceSubtype,
+    delimiter,
+}: StatusIbInfo): string {
+    const lc = `[${getStatusIb.name}]`;
+    try {
+        if (!sagaId) { throw new Error(`sagaId required. (E: cfc923bb29ee4aa788e947b6416740e6)`); }
+        if (statusCode === null || statusCode === undefined) { throw new Error(`status code required. (E: 4e0d232a9955496695012623c2e17ca2)`); }
+        if (!Object.values(StatusCode).includes(statusCode)) { throw new Error(`invalid status code (${statusCode}) (E: 91d7655424c44d9680fff099ee2b54d2)`); }
+        if (!spaceType) { throw new Error(`spaceType required. (E: 86e98694a56a4f599e98e50abf0eed43)`); }
+        if (!spaceSubtype) { throw new Error(`spaceSubtype required. (E: 4857d4677ee34e95aeb2251dd633909e)`); }
+
+        delimiter = delimiter || OUTER_SPACE_DEFAULT_IB_DELIMITER;
+
+        return `status ${sagaId} ${statusCode} ${spaceType} ${spaceSubtype}`;
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}
+
+/**
+ * Parses the given `statusIb` and returns the info object.
+ *
+ * @returns info from parsing the status ib
+ */
+export function getStatusIbInfo({
+    statusIb,
+    delimiter,
+}: {
+    statusIb: Ib,
+    delimiter?: string,
+}): StatusIbInfo {
+    const lc = `[${getStatusIb.name}]`;
+    try {
+        if (!statusIb) { throw new Error(`statusIb required. (E: 09e23e8622cf456cadb0c3d0aadc3be9)`); }
+
+        delimiter = delimiter || OUTER_SPACE_DEFAULT_IB_DELIMITER;
+
+        // atow `status ${sagaId} ${statusCode} ${spaceType} ${spaceSubtype}`;
+        const pieces = statusIb.split(delimiter);
+
+        const sagaId = pieces[1];
+        if (sagaId === null || sagaId === undefined) { throw new Error(`sagaId is null/undefined. (E: 5de2861a6afb48e1a1c89d0402a4ea63)`); }
+
+        const statusCode = pieces[2] as StatusCode; // tenatively cast as StatusCode
+        if (!Object.values(StatusCode).includes(statusCode)) { throw new Error(`invalid/unknown status code (${statusCode}) (E: 7580860df7b344b3992148552e80a85e)`); }
+
+        const spaceType = pieces[3] as OuterSpaceType;
+        if (spaceType === null || spaceType === undefined) { throw new Error(`spaceType is null/undefined. (E: 12473d35e77b451bb59bb05c03cb8b64)`); }
+        if (!VALID_OUTER_SPACE_TYPES.includes(spaceType)) { throw new Error(`invalid/unknown spaceType (${spaceType}) (E: d3ba9add427f49dda34f265f3225d9db)`); }
+
+        const spaceSubtype = pieces[4] as OuterSpaceSubtype;
+        if (spaceSubtype === null || spaceSubtype === undefined) { throw new Error(`spaceSubtype is null/undefined. (E: 6da7ae919d0b4a22b4ee685520b6c946)`); }
+        if (!VALID_OUTER_SPACE_SUBTYPES.includes(spaceSubtype)) { throw new Error(`invalid/unknown spaceSubtype (${spaceSubtype}) (E: 703ed1aee44447a294b3e1cf0984baba)`); }
+
+        return { statusCode, spaceType, spaceSubtype, sagaId, delimiter };
+    } catch (error) {
+        console.error(`${lc} ${error.message}`);
+        throw error;
+    }
+}