flatsql 0.4.0 → 0.4.3

package/wasm/index.d.ts

@@ -29,7 +29,7 @@ export interface FlatSQLDatabase {
   registerFileId(fileId: string, tableName: string): void;
 
   /**
-   * Enable demo field extractors for User and Post tables
+   * Enable built-in demo field extractors for User, Post, MPE, and Telemetry tables
    */
   enableDemoExtractors(): void;
 
@@ -249,6 +249,35 @@ export interface FlatSQL {
    */
   createTestPost(id: number, userId: number, title: string): Uint8Array;
 
+  /**
+   * Create a test CCSDS OMM / MPE FlatBuffer (for demos)
+   */
+  createTestMPE(
+    entityId: string,
+    epoch: number,
+    meanMotion: number,
+    eccentricity: number,
+    inclination: number,
+    raOfAscNode: number,
+    argOfPericenter: number,
+    meanAnomaly: number,
+    bstar: number,
+    meanElementTheory?: number
+  ): Uint8Array;
+
+  /**
+   * Create a test CCSDS-style telemetry FlatBuffer (for demos)
+   */
+  createTestTelemetry(
+    packetId: number,
+    spacecraft: string,
+    subsystem: string,
+    mode: string,
+    temperatureC: number,
+    signalDb: number,
+    timestampS: number
+  ): Uint8Array;
+
   /**
    * Check if WASM was loaded with integrity verification
    */
@@ -283,6 +312,16 @@ export interface InitOptions {
    */
   requireIntegrity?: boolean;
 
+  /**
+   * SHA-384 digest provider used for browser integrity verification.
+   * Browser WebCrypto is intentionally not used; browser callers that require
+   * integrity verification must pass a WASM/native-backed provider.
+   * The result may be a base64 digest string or raw digest bytes.
+   */
+  computeSHA384?: (
+    data: ArrayBuffer
+  ) => Promise<string | Uint8Array | ArrayBuffer> | string | Uint8Array | ArrayBuffer;
+
   /**
    * Custom Emscripten module factory function
    * Default: built-in FlatSQLModule

package/wasm/index.js

@@ -9,30 +9,60 @@ let api = null;
 // Security: Track if integrity was verified
 let integrityVerified = false;
 
+function toBase64(bytes) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    let binary = '';
+    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+    }
+    return btoa(binary);
+}
+
+function normalizeHashResult(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return toBase64(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return toBase64(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    }
+    if (value instanceof ArrayBuffer) {
+        return toBase64(new Uint8Array(value));
+    }
+    throw new Error('SHA-384 provider must return a base64 string or binary digest');
+}
+
+function hasNodeProcess() {
+    return typeof process !== 'undefined' &&
+        process.versions !== undefined &&
+        typeof process.versions.node === 'string';
+}
+
 /**
- * Compute SHA-384 hash of data and return as base64
- * Works in both Node.js and browser environments
+ * Compute SHA-384 hash of data and return as base64.
+ * Browser WebCrypto is intentionally not used; browser callers that require
+ * integrity verification must pass computeSHA384 backed by WASM/native crypto.
  * @param {ArrayBuffer} data
+ * @param {(data: ArrayBuffer) => Promise<string|Uint8Array|ArrayBuffer>|string|Uint8Array|ArrayBuffer} [provider]
  * @returns {Promise<string>}
  */
-async function computeSHA384(data) {
-    if (typeof crypto !== 'undefined' && crypto.subtle) {
-        // Browser or Node.js 18+
-        const hashBuffer = await crypto.subtle.digest('SHA-384', data);
-        const hashArray = new Uint8Array(hashBuffer);
-        // Convert to base64
-        if (typeof btoa !== 'undefined') {
-            return btoa(String.fromCharCode(...hashArray));
-        } else {
-            return Buffer.from(hashArray).toString('base64');
-        }
-    } else {
-        // Node.js fallback using dynamic import
-        const cryptoModule = await import('crypto');
+async function computeSHA384(data, provider) {
+    if (typeof provider === 'function') {
+        return normalizeHashResult(await provider(data));
+    }
+    if (hasNodeProcess()) {
+        const cryptoModule = await import('node:crypto');
         const hash = cryptoModule.createHash('sha384');
         hash.update(Buffer.from(data));
         return hash.digest('base64');
     }
+    throw new Error(
+        'WASM integrity verification requires a computeSHA384 option backed by WASM/native crypto; browser WebCrypto is intentionally not used.'
+    );
 }
 
 /**
@@ -41,8 +71,8 @@ async function computeSHA384(data) {
  * @param {string} expectedHash - Expected SHA-384 hash (base64)
  * @returns {Promise<boolean>}
  */
-async function verifyWASMIntegrity(wasmBinary, expectedHash) {
-    const computedHash = await computeSHA384(wasmBinary);
+async function verifyWASMIntegrity(wasmBinary, expectedHash, options = {}) {
+    const computedHash = await computeSHA384(wasmBinary, options.computeSHA384);
     return computedHash === expectedHash;
 }
 
@@ -177,7 +207,7 @@ export async function initFlatSQL(moduleFactoryOrOptions) {
                 }
 
                 // Verify integrity
-                const isValid = await verifyWASMIntegrity(wasmBinary, expectedIntegrity);
+                const isValid = await verifyWASMIntegrity(wasmBinary, expectedIntegrity, options);
                 if (!isValid) {
                     throw new Error(
                         'WASM integrity check failed: hash mismatch. ' +
@@ -243,6 +273,8 @@ export async function initFlatSQL(moduleFactoryOrOptions) {
         // Test helpers
         createTestUser: Module.cwrap('flatsql_create_test_user', 'number', ['number', 'string', 'string', 'number']),
         createTestPost: Module.cwrap('flatsql_create_test_post', 'number', ['number', 'number', 'string']),
+        createTestMPE: Module.cwrap('flatsql_create_test_mpe', 'number', ['string', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']),
+        createTestTelemetry: Module.cwrap('flatsql_create_test_telemetry', 'number', ['number', 'string', 'string', 'string', 'number', 'number', 'number']),
         testBufferSize: Module.cwrap('flatsql_test_buffer_size', 'number', []),
 
         // Stats
@@ -333,6 +365,30 @@ export class FlatSQL {
         return new Uint8Array(Module.HEAPU8.buffer, ptr, size).slice();
     }
 
+    createTestMPE(entityId, epoch, meanMotion, eccentricity, inclination,
+                  raOfAscNode, argOfPericenter, meanAnomaly, bstar, meanElementTheory = 0) {
+        const ptr = api.createTestMPE(
+            entityId,
+            epoch,
+            meanMotion,
+            eccentricity,
+            inclination,
+            raOfAscNode,
+            argOfPericenter,
+            meanAnomaly,
+            bstar,
+            meanElementTheory
+        );
+        const size = api.testBufferSize();
+        return new Uint8Array(Module.HEAPU8.buffer, ptr, size).slice();
+    }
+
+    createTestTelemetry(packetId, spacecraft, subsystem, mode, temperatureC, signalDb, timestampS) {
+        const ptr = api.createTestTelemetry(packetId, spacecraft, subsystem, mode, temperatureC, signalDb, timestampS);
+        const size = api.testBufferSize();
+        return new Uint8Array(Module.HEAPU8.buffer, ptr, size).slice();
+    }
+
     /**
      * Check if WASM was loaded with integrity verification
      * @returns {boolean}