@ibgib/core-gib 0.0.22 → 0.0.24

package/src/witness/space/filesystem-space/node-filesystem-space-v1.mts

@@ -24,7 +24,9 @@ import {
     IBGIB_ENCODING, IBGIB_IBGIBS_SUBPATH, IBGIB_META_SUBPATH,
     DEFAULT_FILESYSTEM_SPACE_DESCRIPTION,
     IBGIB_BIN_SUBPATH,
-    IBGIB_DNA_SUBPATH
+    IBGIB_DNA_SUBPATH,
+    DEFAULT_LONG_PATH_LENGTH,
+    IBGIB_LONG_SUBPATH,
 } from './filesystem-constants.mjs';
 import { FilesystemSpaceData_V1, FilesystemSpaceOptionsData, FilesystemSpaceOptionsIbGib, FilesystemSpaceOptionsRel8ns, FilesystemSpaceResultData, FilesystemSpaceResultIbGib, FilesystemSpaceResultRel8ns, FilesystemSpace_V1 } from './filesystem-space-v1.mjs';
 
@@ -91,7 +93,7 @@ export interface NodeFilesystemSpaceData_V1 extends FilesystemSpaceData_V1 {
  * (but of course won't be the end of the world when this doesn't happen).
  */
 const DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1: NodeFilesystemSpaceData_V1 = {
-    version: '1',
+    version: '2',
     uuid: ZERO_SPACE_ID,
     name: IBGIB_SPACE_NAME_DEFAULT,
     classname: 'NodeFilesystemSpace_V1',
@@ -101,8 +103,11 @@ const DEFAULT_NODE_FILESYSTEM_SPACE_DATA_V1: NodeFilesystemSpaceData_V1 = {
     spaceSubPath: IBGIB_SPACE_SUBPATH_DEFAULT,
     ibgibsSubPath: IBGIB_IBGIBS_SUBPATH,
     metaSubPath: IBGIB_META_SUBPATH,
-    binSubPath: IBGIB_BASE_SUBPATH,
-    dnaSubPath: IBGIB_BASE_SUBPATH,
+    binSubPath: IBGIB_BIN_SUBPATH,
+    dnaSubPath: IBGIB_DNA_SUBPATH,
+    longSubPath: IBGIB_LONG_SUBPATH,
+    mitigateLongPaths: true,
+    longPathLength: DEFAULT_LONG_PATH_LENGTH,
     persistOptsAndResultIbGibs: false,
     validateIbGibAddrsMatchIbGibs: false,
     longPollingIntervalMs: DEFAULT_LOCAL_SPACE_POLLING_INTERVAL_MS,
@@ -247,10 +252,15 @@ export async function validateNodeFilesystemSpace_V1Intrinsically({ space }: { s
 }
 
 /**
- * Base class convenience for a local space with V1 ibgibs.
+ * Base class convenience for a local space with V1 ibgibs working with the node
+ * filesystem.
  *
- * This naively caches ibGibs in memory. When not found there,
- * will looks in files using Ionic `FileSystem`.
+ * Unfortunately, file systems have short file name requirements, where 255 is
+ * often the max length of a filename. So this cannot store ibgibs directly by
+ * their address.
+ *
+ * This naively caches ibGibs in memory. When not found there, will looks in
+ * files using Ionic `FileSystem`.
  */
 export class NodeFilesystemSpace_V1<
     TData extends NodeFilesystemSpaceData_V1 = NodeFilesystemSpaceData_V1,
@@ -374,6 +384,11 @@ export class NodeFilesystemSpace_V1<
             if (!this.data.binSubPath) { this.data.binSubPath = IBGIB_BIN_SUBPATH; }
             if (!this.data.dnaSubPath) { this.data.dnaSubPath = IBGIB_DNA_SUBPATH; }
 
+            // do nothing, allow falsy
+            if (this.data.longSubPath === undefined) { this.data.longSubPath = IBGIB_LONG_SUBPATH; }
+            if (this.data.longPathLength === undefined) { this.data.longPathLength = DEFAULT_LONG_PATH_LENGTH; }
+            if (this.data.mitigateLongPaths === undefined) { this.data.mitigateLongPaths = true; }
+
             this.ib = getSpaceIb({ space: this, classname: this.data!.classname });
 
             this.gib = await getGib({ ibGib: this });
@@ -401,11 +416,14 @@ export class NodeFilesystemSpace_V1<
             let path: string = "";
             let filename: string = "";
             let data: any = "";
+
             if (ibGib) {
                 const addr = getIbGibAddr({ ibGib });
                 filename = this.getFilename({ addr });
                 const isBin = isBinary({ addr });
-                path = this.buildPath({ filename, isMeta, isDna: isDna ?? false, isBin });
+                path = this.buildPath({
+                    addr, filename, isMeta, isDna: isDna ?? false, isBin,
+                });
 
                 if (!isBin) {
                     // we only want to persist the ibGib protocol
@@ -419,19 +437,11 @@ export class NodeFilesystemSpace_V1<
             }
 
             if (logalot) { console.log(`${lc} path: ${path}, directory: ${thisData.baseDir}, encoding: ${thisData.encoding} (I: d4440ececbe6c859f8fcf6d7ece12522)`); }
-            // throw new Error(`writeFile not implemented yet from capacitor version (E: e096812ae5ec084afd3f3afe874f8423)`);
 
             let fullPath = pathUtils.join(thisData.baseDir, path);
             if (logalot) { console.log(`${lc} fullPath: ${fullPath}`); }
 
             await writeFile(fullPath, data, 'utf8');
-            // const resWrite = await Filesystem.writeFile({
-            //     path,
-            //     data,
-            //     directory: thisData.baseDir,
-            //     encoding: thisData.encoding,
-            // });
-            // if (logalot) { console.log(`${lc} resWrite.uri: ${resWrite.uri}`); }
 
             result.success = true;
         } catch (error) {
@@ -459,12 +469,13 @@ export class NodeFilesystemSpace_V1<
             const data = this.data;
             let path: string = "";
             let filename: string = "";
+
             if (!isBinary({ addr })) {
                 filename = this.getFilename({ addr });
-                path = this.buildPath({ filename, isMeta, isDna: isDna ?? false });
+                path = this.buildPath({ addr, filename, isMeta, isDna: isDna ?? false, });
             } else {
                 filename = this.getFilename({ addr });
-                path = this.buildPath({ filename, isMeta: false, isDna: false, isBin: true });
+                path = this.buildPath({ addr, filename, isMeta: false, isDna: false, isBin: true, });
             }
             if (logalot) { console.log(`${lc} path: ${path}, directory: ${data.baseDir}`); }
             // throw new Error(`deleteFile not implemented yet from capacitor version (E: 06538d1154c71658a72099323553fa23)`);
@@ -503,30 +514,31 @@ export class NodeFilesystemSpace_V1<
             let path: string = "";
             let filename: string = "";
             let paths: string[] = [];
+
             if (!addrIsBin) {
                 filename = this.getFilename({ addr });
 
                 if (isMeta) {
                     // explicitly stating meta, so only look in meta
                     paths = [
-                        this.buildPath({ filename, isMeta: true, isDna: false }),
+                        this.buildPath({ addr, filename, isMeta: true, isDna: false, }),
                     ];
                 } else if (isDna) {
                     // explicitly stating dna, so only look in dna
-                    paths = [this.buildPath({ filename, isMeta: false, isDna: true }),];
+                    paths = [this.buildPath({ addr, filename, isMeta: false, isDna: true, }),];
                 } else {
                     // could be regular, meta or dna, so we'll search everywhere, but first regular.
                     paths = [
-                        this.buildPath({ filename, isMeta: false, isDna: false }),
-                        this.buildPath({ filename, isMeta: true, isDna: false }),
-                        this.buildPath({ filename, isMeta: false, isDna: true }),
+                        this.buildPath({ addr, filename, isMeta: false, isDna: false, }),
+                        this.buildPath({ addr, filename, isMeta: true, isDna: false, }),
+                        this.buildPath({ addr, filename, isMeta: false, isDna: true, }),
                     ];
                 }
             } else {
                 // const addr = getBinAddr({binHash, binExt});
                 filename = this.getFilename({ addr });
                 // filename = this.getFilename({binHash, binExt});
-                path = this.buildPath({ filename, isDna: false, isMeta: false, isBin: true })
+                path = this.buildPath({ addr, filename, isDna: false, isMeta: false, isBin: true, })
                 paths = [path];
             }
             let resRead: any = null;
@@ -628,6 +640,10 @@ export class NodeFilesystemSpace_V1<
             data.baseSubPath + '/' + data.spaceSubPath + '/' + data.dnaSubPath,
         ];
 
+        if (data.mitigateLongPaths) {
+            paths.push(data.baseSubPath + '/' + data.spaceSubPath + '/' + data.longSubPath);
+        }
+
         const getPathKey = (p: string) => { return directory.toString() + '/' + p; }
 
         let allExist = paths.every(path => this.pathExistsMap[getPathKey(path)]);

package/src/witness/space/filesystem-space/node-filesystem-space-v1.node.respec.mts

@@ -71,7 +71,7 @@ await respecfully(sir, `[${NodeFilesystemSpace_V1.name} specs]`, async () => {
 
     await testSpace_PutGetDelete({
         respecfulTitle: sir,
-        // shortcircuitRespec: true,
+        shortcircuitRespec: true,
         fnBeforeEach: async () => {
 
         },

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

@@ -3,6 +3,7 @@ import {
     lastOfEach, lastOfAll,
     ifWeMight, iReckon, respecfully
 } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+import { pickRandom_Letters } from '@ibgib/helper-gib';
 // const maam = `[${import.meta.url}]`, sir = maam;
 import { IbGibAddr, getIbGibAddr } from "@ibgib/ts-gib";
 import { IbGib_V1, } from "@ibgib/ts-gib/dist/V1/types.mjs";
@@ -66,7 +67,6 @@ export async function testSpace_createAndInit({
 }: CommonSpaceSpecOptions): Promise<void> {
     const logContext = `[${testSpace_PutGetDelete.name}]${desc ?? ''}`;
 
-    debugger;
     await respecfully(sir, logContext, async () => {
 
         let initialData: any | undefined;
@@ -87,7 +87,6 @@ export async function testSpace_createAndInit({
 
         const fnIfWeBlock: any = shortcircuitRespec ? ifWeMight : ifWe;
 
-        debugger;
         await fnIfWeBlock(sir, `when created and initialized, space should be initialized`, async () => {
             space = await fnGetSpace(initialData, initialRel8ns);
             await space.initialized;
@@ -202,6 +201,43 @@ export async function testSpace_PutGetDelete({
             iReckon(sir, resGet.errorMsg).asTo('resGet after delete').isGonnaBeTruthy();
             iReckon(sir, resGet.ibGibs).asTo('resGet after delete').isGonnaBeUndefined();
         });
+
+        const testLengths = [255, 256, 300, 500, 1000];
+        for (let i = 0; i < testLengths.length; i++) {
+            const testLength = testLengths[i];
+            await fnIfWeBlock(sir, `${logContext}, should put/get/delete LONG addr (${testLength} length)`, async () => {
+                let newIbGib: IbGib_V1 = {
+                    ib: pickRandom_Letters({ count: testLength }),
+                    data: { x: 1 },
+                    rel8ns: { ancestor: ['test yo^gib'] }
+                }
+                newIbGib.gib = await getGib({ ibGib: newIbGib, hasTjp: false });
+                const newIbGibAddr: IbGibAddr = getIbGibAddr({ ibGib: newIbGib });
+
+                // put
+                let resPut = await putInSpace({ ibGib: newIbGib, space });
+                iReckon(sir, resPut).asTo('resPut').isGonnaBeTruthy();
+                iReckon(sir, resPut.success).isGonnaBeTrue();
+
+                // get
+                let resGet = await getFromSpace({ addr: newIbGibAddr, space });
+                iReckon(sir, resGet).asTo('resGet').isGonnaBeTruthy();
+                iReckon(sir, resGet.success).asTo('resGet').isGonnaBeTrue();
+                iReckon(sir, resGet.errorMsg).asTo('resGet').isGonnaBeFalsy();
+                iReckon(sir, resGet.ibGibs).asTo('resGet').isGonnaBeTruthy();
+                iReckon(sir, resGet.ibGibs!.length).asTo('resGet').isGonnaBe(1);
+                iReckon(sir, resGet.ibGibs![0]).asTo('resGet').isGonnaBe(newIbGib);
+
+                // delete
+                await deleteFromSpace({ addr: newIbGibAddr, space });
+                resGet = await getFromSpace({ addr: newIbGibAddr, space });
+                iReckon(sir, resGet).asTo('resGet after delete').isGonnaBeTruthy();
+                iReckon(sir, resGet.success).asTo('resGet after delete').isGonnaBeFalse();
+                iReckon(sir, resGet.errorMsg).asTo('resGet after delete').isGonnaBeTruthy();
+                iReckon(sir, resGet.ibGibs).asTo('resGet after delete').isGonnaBeUndefined();
+            });
+
+        }
     });
 }
 

package/src/witness/space/space-types.mts

@@ -71,8 +71,26 @@ export interface IbGibSpaceData_Subpathed extends IbGibSpaceData {
     uuid: SpaceId;
     baseDir: string | any;
     encoding: string | any;
+    /**
+     * this is to help mitigate against too long path limits
+     */
+    mitigateLongPaths?: boolean;
+    /**
+     * if mitigating against long path lengths, this is the deciding split.
+     *
+     * so if the longPathLength is 250, and a full path would be 250, then
+     * that is now a long path. 249 would be a short path and would not need
+     * mitigation.
+     */
+    longPathLength?: number;
     baseSubPath: string;
     spaceSubPath: string;
+    /**
+     * if a filepath is too long, things get stuffed in here
+     *
+     * this is to help mitigate against too long path limits
+     */
+    longSubPath?: string;
     ibgibsSubPath: string;
     metaSubPath: string;
     binSubPath: string;