@quereus/quereus 0.6.2 → 0.6.4

package/src/util/hash.ts

@@ -0,0 +1,90 @@
+/**
+ * Hash and encoding utilities
+ */
+
+/**
+ * Computes FNV-1a hash of a string (64-bit variant)
+ * Returns an 8-byte array representing the hash
+ * 
+ * FNV-1a is a fast, non-cryptographic hash function with good distribution.
+ * See: http://www.isthe.com/chongo/tech/comp/fnv/
+ */
+export function fnv1aHash(str: string): Uint8Array {
+	// FNV-1a 64-bit parameters
+	// Using two 32-bit integers to represent 64-bit hash (JavaScript limitation)
+	let hashHigh = 0xcbf29ce4; // Upper 32 bits of FNV offset basis
+	let hashLow = 0x84222325;  // Lower 32 bits of FNV offset basis
+	
+	const fnvPrimeHigh = 0x00000100; // Upper 32 bits of FNV prime
+	const fnvPrimeLow = 0x000001b3;  // Lower 32 bits of FNV prime
+
+	for (let i = 0; i < str.length; i++) {
+		const charCode = str.charCodeAt(i);
+		
+		// XOR with byte (handle multi-byte characters)
+		hashLow ^= charCode & 0xff;
+		
+		// Multiply by FNV prime (64-bit multiplication using 32-bit parts)
+		const aHigh = hashHigh;
+		const aLow = hashLow;
+		
+		hashLow = (aLow * fnvPrimeLow) >>> 0;
+		hashHigh = (aHigh * fnvPrimeLow + aLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
+		hashLow = hashLow >>> 0;
+		
+		// Handle high byte of character if present
+		if (charCode > 0xff) {
+			hashLow ^= (charCode >>> 8) & 0xff;
+			const bHigh = hashHigh;
+			const bLow = hashLow;
+			hashLow = (bLow * fnvPrimeLow) >>> 0;
+			hashHigh = (bHigh * fnvPrimeLow + bLow * fnvPrimeHigh + (hashLow / 0x100000000)) >>> 0;
+			hashLow = hashLow >>> 0;
+		}
+	}
+
+	// Convert to 8-byte array
+	const bytes = new Uint8Array(8);
+	bytes[0] = (hashHigh >>> 24) & 0xff;
+	bytes[1] = (hashHigh >>> 16) & 0xff;
+	bytes[2] = (hashHigh >>> 8) & 0xff;
+	bytes[3] = hashHigh & 0xff;
+	bytes[4] = (hashLow >>> 24) & 0xff;
+	bytes[5] = (hashLow >>> 16) & 0xff;
+	bytes[6] = (hashLow >>> 8) & 0xff;
+	bytes[7] = hashLow & 0xff;
+	
+	return bytes;
+}
+
+/**
+ * Converts a byte array to base64url encoding
+ * (URL-safe base64 without padding: uses - and _ instead of + and /, no = padding)
+ * 
+ * Base64url is defined in RFC 4648 Section 5.
+ */
+export function toBase64Url(bytes: Uint8Array): string {
+	const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+	let result = '';
+	
+	for (let i = 0; i < bytes.length; i += 3) {
+		// Get 3 bytes (24 bits) and convert to 4 base64 characters (6 bits each)
+		const byte1 = bytes[i];
+		const byte2 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+		const byte3 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+		
+		const triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+		
+		result += base64Chars[(triplet >>> 18) & 0x3f];
+		result += base64Chars[(triplet >>> 12) & 0x3f];
+		if (i + 1 < bytes.length) {
+			result += base64Chars[(triplet >>> 6) & 0x3f];
+		}
+		if (i + 2 < bytes.length) {
+			result += base64Chars[triplet & 0x3f];
+		}
+	}
+	
+	return result;
+}
+

package/src/util/plugin-helper.ts

@@ -0,0 +1,110 @@
+/**
+ * Plugin registration helper for static plugin loading
+ * 
+ * This module provides utilities for registering plugins without dynamic imports,
+ * which is useful for React Native and other environments where dynamic imports
+ * are not supported.
+ */
+
+import type { Database } from '../core/database.js';
+import type { PluginRegistrations } from '../vtab/manifest.js';
+import type { SqlValue } from '../common/types.js';
+
+/**
+ * Plugin function type - what a plugin exports as its default export
+ */
+export type PluginFunction = (
+	db: Database,
+	config?: Record<string, SqlValue>
+) => Promise<PluginRegistrations> | PluginRegistrations;
+
+/**
+ * Register a plugin's components with the database.
+ * 
+ * This is a helper function for static plugin loading that handles calling
+ * the plugin function and registering all returned components (vtables,
+ * functions, collations, types) with the database.
+ * 
+ * @param db Database instance to register with
+ * @param plugin Plugin function (the default export from a plugin module)
+ * @param config Optional configuration object to pass to the plugin
+ * 
+ * @example
+ * ```typescript
+ * import { Database } from '@quereus/quereus';
+ * import { registerPlugin } from '@quereus/quereus';
+ * import myPlugin from './plugins/my-plugin';
+ * 
+ * const db = new Database();
+ * await registerPlugin(db, myPlugin, { apiKey: 'secret' });
+ * ```
+ * 
+ * @example
+ * ```typescript
+ * // Register multiple plugins
+ * await registerPlugin(db, stringFunctions);
+ * await registerPlugin(db, customCollations);
+ * await registerPlugin(db, jsonTable, { cacheSize: 100 });
+ * ```
+ */
+export async function registerPlugin(
+	db: Database,
+	plugin: PluginFunction,
+	config: Record<string, SqlValue> = {}
+): Promise<void> {
+	// Call the plugin function to get registrations
+	const registrations = await plugin(db, config);
+
+	// Register virtual table modules
+	if (registrations.vtables) {
+		for (const vtable of registrations.vtables) {
+			try {
+				db.registerVtabModule(vtable.name, vtable.module, vtable.auxData);
+			} catch (error) {
+				throw new Error(
+					`Failed to register vtable module '${vtable.name}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+
+	// Register functions
+	if (registrations.functions) {
+		for (const func of registrations.functions) {
+			try {
+				db.registerFunction(func.schema);
+			} catch (error) {
+				throw new Error(
+					`Failed to register function '${func.schema.name}/${func.schema.numArgs}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+
+	// Register collations
+	if (registrations.collations) {
+		for (const collation of registrations.collations) {
+			try {
+				db.registerCollation(collation.name, collation.func);
+			} catch (error) {
+				throw new Error(
+					`Failed to register collation '${collation.name}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+
+	// Register types
+	if (registrations.types) {
+		for (const type of registrations.types) {
+			try {
+				db.registerType(type.name, type.definition);
+			} catch (error) {
+				throw new Error(
+					`Failed to register type '${type.name}': ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+}
+