@ibgib/node-gib 0.0.10 → 0.0.14

package/src/serve-gib/serve-gib.respec.mts

@@ -0,0 +1,90 @@
+import { respecfully, iReckon, ifWe } from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+import { ServeGib_V1 } from './serve-gib-v1.mjs';
+import { HealthHandler } from './handlers/api/health.handler.mjs';
+import { ErrorHandler } from './handlers/error-handler.mjs';
+
+const sir = `[${import.meta.url}]`;
+
+await respecfully(sir, 'ServeGib ServeGib_V1', async () => {
+
+    await ifWe(sir, 'construct a RouteInfo object', async () => {
+        const serveGib = new ServeGib_V1({
+            port: 3000,
+            dataDir: './test-data',
+            handlers: [],
+            errorHandler: new ErrorHandler()
+        });
+
+        // Mock request
+        const req: any = {
+            url: '/api/health?foo=bar',
+            method: 'GET',
+            headers: { 'x-forwarded-proto': 'https' },
+            on: (event: string, cb: any) => {
+                if (event === 'end') { cb(); }
+            } // immediate end for readBody
+        };
+
+        const info = await serveGib.prepareContext(req);
+
+        iReckon(sir, info.pathname).isGonnaBe('/api/health');
+        iReckon(sir, info.method).isGonnaBe('GET');
+        iReckon(sir, info.protocol).isGonnaBe('https');
+        iReckon(sir, info.decodedPathSegments).includes('api');
+        iReckon(sir, info.decodedPathSegments).includes('health');
+    });
+
+    await ifWe(sir, 'execute a handler in the pipeline', async () => {
+        const health = new HealthHandler();
+        const serveGib = new ServeGib_V1({
+            port: 3000,
+            dataDir: './test-data',
+            handlers: [health],
+            errorHandler: new ErrorHandler()
+        });
+
+        // Mock objects
+        const req: any = {
+            url: '/api/health',
+            method: 'GET',
+            headers: {},
+            on: (event: string, cb: any) => {
+                if (event === 'end') { cb(); }
+            }
+        };
+        const res: any = {
+            writeHead: () => { },
+            end: () => { },
+            statusCode: 200
+        };
+
+        await serveGib.handleRequest(req, res);
+        iReckon(sir, res.statusCode).isGonnaBe(200);
+    });
+
+    await ifWe(sir, 'fall back to error handler when no handler matches', async () => {
+        const serveGib = new ServeGib_V1({
+            port: 3000,
+            dataDir: './test-data',
+            handlers: [],
+            errorHandler: new ErrorHandler()
+        });
+
+        const req: any = {
+            url: '/not/found',
+            method: 'GET',
+            headers: {},
+            on: (event: string, cb: any) => {
+                if (event === 'end') { cb(); }
+            }
+        };
+        const res: any = {
+            writeHead: () => { },
+            end: () => { },
+            statusCode: 404
+        };
+
+        await serveGib.handleRequest(req, res);
+        iReckon(sir, res.statusCode).isGonnaBe(404);
+    });
+});

package/src/serve-gib/server-constants.mts

@@ -0,0 +1,2 @@
+export const GLOBAL_LOG_A_LOT = false;
+export const GLOBAL_TIMER_NAME = '[space^gib server timer]';

package/src/serve-gib/types.mts

@@ -0,0 +1,102 @@
+/**
+ * @module serve-gib/types
+ *
+ * Foundational types for the serve-gib microframework.
+ */
+
+import { Gib, Ib, IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+import { GibInfo } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { MetaspaceService } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-types.mjs';
+
+/**
+ * Standard HTTP methods supported by the serve-gib framework, plus 'ALL' for catch-all handlers.
+ */
+export type ServeGibHttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'ALL';
+
+/**
+ * @see {@link RequestContext.domainInfo}
+ */
+export interface DomainInfo {
+    ib: Ib;
+    gib: Gib;
+    addr: IbGibAddr;
+    gibInfo: GibInfo;
+    /** The physical root directory for the current domain. */
+    // rootPath?: string;
+}
+
+export interface ParamsWithDomain {
+    domainInfo: DomainInfo;
+}
+
+/**
+ * Encapsulates the context of an incoming HTTP request.
+ */
+export interface RequestContext<TParams = any, TQueryParams = any> {
+    /** The native Node.js/Web URL object. */
+    url: URL;
+    /** The root data directory for spaces. */
+    dataDir: string;
+    /** The original request URL string. */
+    rawUrl: string;
+    /** The pathname part of the URL (e.g. /api/health). */
+    pathname: string;
+    /** HTTP method (GET, POST, etc.). */
+    method: ServeGibHttpMethod;
+    /** Request protocol (http or https). */
+    protocol: string;
+    /** The raw request body as a string. */
+    body: string;
+    /** Array of raw path segments split by '/'. */
+    rawPathSegments: string[];
+    /**
+     * Same as {@link rawPathSegments}, but with any ibgib addr(s) URL decoded.
+     */
+    decodedPathSegments: string[];
+    params?: TParams;
+    /** Parsed query parameters. */
+    queryParams?: TQueryParams;
+    /** Request headers. */
+    headers: Record<string, string | string[] | undefined>;
+    /**
+     * The bootstrapped MetaspaceService for the current domain.
+     *
+     * Note that not all routes require this, hence it's optional.
+     */
+    metaspace?: MetaspaceService;
+    /**
+     * keystones define "domains" to enable multitenancy. This is info about the
+     * keystone domain.
+     *
+     * ## notes
+     *
+     * I would call this "KeystoneInfo", and right now, this is only one keystone's
+     * info. but ultimately I _think_ that we will have nested domains.
+     */
+    domainInfo?: DomainInfo;
+}
+
+/**
+ * Standardized response shape returned by handlers.
+ */
+export interface ResponseResult {
+    /** HTTP status code (200, 404, etc.). */
+    status: number;
+    /** Optional response headers. */
+    headers?: Record<string, string>;
+    /** Response body content. */
+    body: any;
+    /** If true, body will be stringified as JSON and Content-Type set accordingly. */
+    isJson?: boolean;
+}
+
+/**
+ * Interface for a serve-gib route handler.
+ */
+export interface ServeGibHandler<TParams, TQueryParams> {
+    /**
+     * Attempts to handle the request.
+     * @returns A ResponseResult if handled, or undefined to pass to the next handler.
+     */
+    handleRoute(reqCtx: RequestContext<TParams, TQueryParams>): Promise<ResponseResult | undefined>;
+}

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

@@ -6,15 +6,19 @@
  * of in terms of a node in a p2p network.
  */
 
+import * as fs from 'fs';
+import * as path from 'path';
 import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { IbGibSpaceAny } from '@ibgib/core-gib/dist/witness/space/space-base-v1.mjs';
 import { IbGibCacheService } from '@ibgib/core-gib/dist/common/cache/cache-types.mjs';
 import { MetaspaceBase } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-base.mjs';
 import { MetaspaceFactory } from '@ibgib/core-gib/dist/witness/space/metaspace/metaspace-types.mjs';
+import { SpaceId } from '@ibgib/core-gib/dist/witness/space/space-types.mjs';
 
 import { GLOBAL_LOG_A_LOT, GLOBAL_TIMER_NAME } from '../../../../constants.mjs';
 import { fnCreateNewLocalSpace, fnDtoToSpace_nodeFilesystem } from './metaspace-nodespace-helper.mjs';
 import { NodeFilesystemSpace_V1 } from '../../node-filesystem-space/node-filesystem-space-v1.mjs';
+import { NodeFilesystemSpaceData_V1 } from '../../node-filesystem-space/node-filesystem-space-types.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
 
@@ -163,4 +167,41 @@ export class Metaspace_Nodespace extends MetaspaceBase {
     }
   }
 
+  override async deleteLocalUserSpace({
+    spaceId,
+    deletePhysicalStorage = true,
+  }: {
+    spaceId: SpaceId;
+    deletePhysicalStorage?: boolean;
+  }): Promise<void> {
+    const lc = `${this.lc}[${this.deleteLocalUserSpace.name}]`;
+    try {
+      if (logalot) { console.log(`${lc} starting... spaceId: ${spaceId} (I: b9a18204b12541a590b512a8e0915623)`); }
+      if (!spaceId) { throw new Error(`spaceId required. (E: 73a210410a124b819e917f9db0972b23)`); }
+
+      // 1. Get space instance first to read physical directory path
+      const space = await this.getLocalUserSpace({ localSpaceId: spaceId });
+
+      // 2. Deregister space from bootstrap^gib and delete space record from zeroSpace via super
+      await super.deleteLocalUserSpace({ spaceId, deletePhysicalStorage });
+
+      // 3. Delete physical directory on disk if requested
+      if (deletePhysicalStorage && space) {
+        const spaceData = space.data as NodeFilesystemSpaceData_V1;
+        if (spaceData?.baseSubPath && spaceData?.spaceSubPath) {
+          const spaceDirPath = path.join(spaceData.baseSubPath, spaceData.spaceSubPath);
+          if (fs.existsSync(spaceDirPath)) {
+            if (logalot) { console.log(`${lc} removing space directory on disk: ${spaceDirPath} (I: e9410a5170d14b4fb2478d102e3b2e23)`); }
+            fs.rmSync(spaceDirPath, { recursive: true, force: true });
+          }
+        }
+      }
+
+      if (logalot) { console.log(`${lc} complete.`); }
+    } catch (error) {
+      console.error(`${lc} ${extractErrorMsg(error)}`);
+      throw error;
+    }
+  }
+
 }

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

@@ -91,7 +91,7 @@ export async function tryRead_bin({
             ...FILE_ENCODINGS,
         ]);
         let { dataBuffer, dataString, inputPath, detectedEncoding } = await getFileDataAndEncoding({
-            inputPath: path,
+            inputPath: fullPath,
             encodingsToTry,
         });
         if (!dataBuffer) { throw new Error(`getFileDataAndEncoding yielded falsy dataBuffer (E: f7aac299212a1ae41d5bbef6079c4d24)`); }