mindoodb 0.0.2 → 0.0.3

package/templates/reactnative/App.js

@@ -0,0 +1,252 @@
+import React, { useState, useEffect } from 'react';
+import { StatusBar } from 'expo-status-bar';
+import {
+  StyleSheet,
+  Text,
+  View,
+  Button,
+  ScrollView,
+  ActivityIndicator,
+  Platform,
+} from 'react-native';
+
+// Lazy-load MindooDB to avoid blocking app registration
+let BaseMindooTenantFactory, InMemoryContentAddressedStoreFactory, KeyBag, PUBLIC_INFOS_KEY_ID;
+let QuickCryptoAdapter = null;
+let ReactNativeCryptoAdapter = null;
+let mindoodbLoaded = false;
+let mindoodbLoadError = null;
+
+function loadMindooDB() {
+  if (mindoodbLoaded) return;
+  try {
+    const mindoodb = require('mindoodb');
+    BaseMindooTenantFactory = mindoodb.BaseMindooTenantFactory;
+    InMemoryContentAddressedStoreFactory = mindoodb.InMemoryContentAddressedStoreFactory;
+    KeyBag = mindoodb.KeyBag;
+    PUBLIC_INFOS_KEY_ID = mindoodb.PUBLIC_INFOS_KEY_ID;
+    QuickCryptoAdapter = mindoodb.QuickCryptoAdapter;
+    ReactNativeCryptoAdapter = mindoodb.ReactNativeCryptoAdapter;
+    mindoodbLoaded = true;
+  } catch (error) {
+    mindoodbLoadError = error;
+  }
+}
+
+export default function App() {
+  const [testStatus, setTestStatus] = useState('idle');
+  const [testResults, setTestResults] = useState('');
+  const [isRunning, setIsRunning] = useState(false);
+
+  useEffect(() => {
+    if (!mindoodbLoaded && !mindoodbLoadError) loadMindooDB();
+  }, []);
+
+  const log = (msg) => setTestResults((prev) => prev + msg + '\n');
+
+  const runTest = async () => {
+    setIsRunning(true);
+    setTestStatus('running');
+    setTestResults('Starting test...\n');
+
+    try {
+      if (!mindoodbLoaded) throw new Error(mindoodbLoadError?.message || 'MindooDB not loaded');
+
+      // ── Step 1: Create store factory ──
+      log('Creating store factory...');
+      const storeFactory = new InMemoryContentAddressedStoreFactory();
+
+      // ── Step 2: Create crypto adapter ──
+      log(`Creating crypto adapter (${Platform.OS})...`);
+      const quickCrypto = require('react-native-quick-crypto');
+      const cryptoAdapter = new QuickCryptoAdapter(quickCrypto);
+      const subtle = cryptoAdapter.getSubtle();
+      log('Crypto adapter ready');
+
+      // ── Native crypto diagnostics ──
+      log('Running native crypto diagnostics...');
+      try {
+        const hash = quickCrypto.createHash('sha256');
+        hash.update('mindoodb-test');
+        hash.digest('hex');
+        log('  Hash.digest() works');
+      } catch (e) {
+        log(`  Hash.digest() failed: ${e.message}`);
+      }
+      try {
+        await quickCrypto.subtle.digest('SHA-256', new Uint8Array([9, 8, 7, 6]));
+        log('  SubtleCrypto.digest() works');
+      } catch (e) {
+        log(`  SubtleCrypto.digest() failed: ${e.message}`);
+      }
+      try {
+        quickCrypto.getRandomValues(new Uint8Array(8));
+        log('  getRandomValues() works');
+      } catch (e) {
+        log(`  getRandomValues() failed: ${e.message}`);
+      }
+
+      // ── Step 3: Create tenant factory ──
+      log('Creating tenant factory...');
+      const factory = new BaseMindooTenantFactory(storeFactory, cryptoAdapter);
+
+      // ── Step 4: Create admin user + keys ──
+      log('Creating admin user...');
+      const adminUserPassword = 'adminpass123';
+      const adminUser = await factory.createUserId('CN=admin/O=testtenant', adminUserPassword);
+      log('Admin user created');
+
+      log('Creating key pairs...');
+      const adminSigningKeyPair = await factory.createSigningKeyPair('signingpass');
+      const adminEncryptionKeyPair = await factory.createEncryptionKeyPair('encpass');
+      const tenantEncryptionKey = await factory.createSymmetricEncryptedPrivateKey('tenantpass');
+      const publicInfosKey = await factory.createSymmetricEncryptedPrivateKey('publicinfospass');
+
+      log('Creating KeyBag...');
+      const adminKeyBag = new KeyBag(
+        adminUser.userEncryptionKeyPair.privateKey,
+        adminUserPassword,
+        cryptoAdapter
+      );
+      await adminKeyBag.decryptAndImportKey(PUBLIC_INFOS_KEY_ID, publicInfosKey, 'publicinfospass');
+
+      // ── Step 5: Open tenant ──
+      log('Opening tenant...');
+      const tenant = await factory.openTenantWithKeys(
+        'test-tenant',
+        tenantEncryptionKey,
+        'tenantpass',
+        adminSigningKeyPair.publicKey,
+        adminEncryptionKeyPair.publicKey,
+        adminUser,
+        adminUserPassword,
+        adminKeyBag
+      );
+
+      log('Registering admin user...');
+      const directory = await tenant.openDirectory();
+      await directory.registerUser(
+        factory.toPublicUserId(adminUser),
+        adminSigningKeyPair.privateKey,
+        'signingpass'
+      );
+
+      // ── Step 6: Document test ──
+      log('\n=== Document Test ===');
+      const db = await tenant.openDB('test-db');
+      const numDocs = 10;
+      const createdDocs = [];
+      const baseTime = Date.now();
+
+      log(`Creating ${numDocs} documents...`);
+      for (let i = 0; i < numDocs; i++) {
+        const doc = await db.createDocument();
+        const docId = doc.getId();
+        await db.changeDoc(doc, (d) => {
+          const data = d.getData();
+          data.index = i;
+          data.timestamp = baseTime + i;
+        });
+        const updatedDoc = await db.getDocument(docId);
+        createdDocs.push({ docId, lastModified: updatedDoc.getLastModified() });
+        await new Promise((r) => setTimeout(r, 1));
+      }
+
+      await db.syncStoreChanges();
+
+      log('Iterating documents...');
+      const processedDocs = [];
+      for await (const { doc, cursor } of db.iterateChangesSince(null)) {
+        processedDocs.push({ docId: doc.getId(), lastModified: doc.getLastModified(), cursor });
+      }
+
+      // ── Verify ──
+      log('\n=== Results ===');
+      const allProcessed = processedDocs.length === numDocs;
+      log(`Documents: ${processedDocs.length}/${numDocs} ${allProcessed ? 'PASS' : 'FAIL'}`);
+
+      let orderCorrect = true;
+      for (let i = 1; i < processedDocs.length; i++) {
+        const prev = processedDocs[i - 1];
+        const curr = processedDocs[i];
+        if (prev.lastModified === curr.lastModified) {
+          if (prev.docId.localeCompare(curr.docId) > 0) { orderCorrect = false; break; }
+        } else if (prev.lastModified > curr.lastModified) { orderCorrect = false; break; }
+      }
+      log(`Order: ${orderCorrect ? 'PASS' : 'FAIL'}`);
+
+      let cursorCorrect = true;
+      for (const result of processedDocs) {
+        if (result.cursor.docId !== result.docId || result.cursor.lastModified !== result.lastModified) {
+          cursorCorrect = false;
+          break;
+        }
+      }
+      log(`Cursors: ${cursorCorrect ? 'PASS' : 'FAIL'}`);
+
+      if (allProcessed && orderCorrect && cursorCorrect) {
+        setTestStatus('success');
+        log('\n=== TEST PASSED ===');
+        console.log('=== TEST PASSED ===');
+      } else {
+        setTestStatus('error');
+        log('\n=== TEST FAILED ===');
+        console.error('=== TEST FAILED ===');
+      }
+    } catch (error) {
+      setTestStatus('error');
+      log(`\nERROR: ${error.message}\n${error.stack || ''}`);
+      console.error('Test error:', error);
+    } finally {
+      setIsRunning(false);
+    }
+  };
+
+  return (
+    <View style={styles.container}>
+      <StatusBar style="auto" />
+      <Text style={styles.title}>MindooDB Test App</Text>
+      <Text style={styles.subtitle}>React Native Integration Test</Text>
+
+      <View style={styles.buttonContainer}>
+        <Button
+          title={isRunning ? 'Running Test...' : 'Run Test (10 docs)'}
+          onPress={runTest}
+          disabled={isRunning}
+          color="#007AFF"
+        />
+      </View>
+
+      {isRunning && (
+        <View style={styles.loadingContainer}>
+          <ActivityIndicator size="large" color="#007AFF" />
+          <Text style={styles.loadingText}>Running test...</Text>
+        </View>
+      )}
+
+      {testStatus !== 'idle' && (
+        <View style={styles.resultsContainer}>
+          <Text style={styles.resultsTitle}>Test Results:</Text>
+          <ScrollView style={styles.resultsScroll}>
+            <Text style={styles.resultsText}>{testResults}</Text>
+          </ScrollView>
+        </View>
+      )}
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: { flex: 1, backgroundColor: '#fff', padding: 20, paddingTop: 60 },
+  title: { fontSize: 24, fontWeight: 'bold', marginBottom: 5, textAlign: 'center' },
+  subtitle: { fontSize: 16, color: '#666', textAlign: 'center', marginBottom: 30 },
+  buttonContainer: { marginBottom: 20 },
+  loadingContainer: { alignItems: 'center', marginVertical: 20 },
+  loadingText: { marginTop: 10, color: '#666' },
+  resultsContainer: {
+    flex: 1, borderWidth: 1, borderColor: '#ddd', borderRadius: 8, padding: 10, marginTop: 10,
+  },
+  resultsTitle: { fontSize: 18, fontWeight: 'bold', marginBottom: 10 },
+  resultsScroll: { flex: 1 },
+  resultsText: { fontSize: 12, fontFamily: 'monospace', color: '#333' },
+});

package/templates/reactnative/app.json

@@ -0,0 +1,29 @@
+{
+  "expo": {
+    "name": "my-mindoodb-app",
+    "slug": "my-mindoodb-app",
+    "version": "1.0.0",
+    "orientation": "portrait",
+    "icon": "./assets/splash-icon.png",
+    "userInterfaceStyle": "light",
+    "splash": {
+      "image": "./assets/splash-icon.png",
+      "resizeMode": "contain",
+      "backgroundColor": "#ffffff"
+    },
+    "assetBundlePatterns": ["**/*"],
+    "ios": {
+      "supportsTablet": true,
+      "bundleIdentifier": "com.example.myapp",
+      "jsEngine": "jsc"
+    },
+    "android": {
+      "adaptiveIcon": {
+        "foregroundImage": "./assets/adaptive-icon.png",
+        "backgroundColor": "#ffffff"
+      },
+      "package": "com.example.myapp"
+    },
+    "newArchEnabled": true
+  }
+}

package/templates/reactnative/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = function(api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+  };
+};

package/templates/reactnative/index.js

@@ -0,0 +1,26 @@
+// MindooDB React Native Entry Point
+//
+// This file loads polyfills, initializes native Automerge via UseApi(nativeApi),
+// then registers the app. Use this as a reference for your own index.js.
+
+// Polyfills MUST be imported first (atob/btoa, crypto, TextDecoder, URL)
+import './mindoodb-polyfills';
+
+// Initialize native Automerge before registering the app
+(async () => {
+  try {
+    const { UseApi } = require('@automerge/automerge/slim');
+    const { nativeApi } = require('react-native-automerge-generated');
+    UseApi(nativeApi);
+    console.log('Automerge native backend initialized');
+
+    // Register the app
+    const registerRootComponent = require('expo/src/launch/registerRootComponent').default;
+    const App = require('./App').default;
+    registerRootComponent(App);
+  } catch (error) {
+    console.error('MindooDB initialization failed:', error.message);
+    console.error(error.stack);
+    throw error;
+  }
+})();

package/templates/reactnative/metro.config.snippet.js

@@ -0,0 +1,39 @@
+// ── MindooDB Metro Configuration ─────────────────────────────────────
+//
+// Add these settings to your metro.config.js.
+// This snippet assumes you already have:
+//   const { getDefaultConfig } = require('expo/metro-config');
+//   const config = getDefaultConfig(__dirname);
+//
+// Paste the sections below BEFORE `module.exports = config;`
+
+const path = require('path');
+
+// Enable package exports for conditional imports (react-native, browser, node)
+config.resolver.unstable_enablePackageExports = true;
+
+// Prefer react-native field, then browser, then module, then main
+config.resolver.resolverMainFields = ['react-native', 'browser', 'module', 'main'];
+
+// Custom resolver: keep Automerge on the slim build for UseApi(nativeApi)
+// and avoid accidental WASM/fullfat entrypoint usage.
+const originalResolveRequest = config.resolver.resolveRequest;
+
+config.resolver.resolveRequest = (context, moduleName, platform) => {
+  // Redirect @automerge/automerge and subpaths to slim.cjs
+  if (moduleName === '@automerge/automerge' || moduleName.startsWith('@automerge/automerge/')) {
+    const slim = path.resolve(
+      __dirname,
+      'node_modules/@automerge/automerge/dist/cjs/slim.cjs'
+    );
+    if (require('fs').existsSync(slim)) {
+      return { filePath: slim, type: 'sourceFile' };
+    }
+  }
+
+  // Default resolution
+  if (originalResolveRequest) {
+    return originalResolveRequest(context, moduleName, platform);
+  }
+  return context.resolveRequest(context, moduleName, platform);
+};

package/templates/reactnative/mindoodb-polyfills.js

@@ -0,0 +1,116 @@
+/**
+ * MindooDB Polyfills for React Native
+ *
+ * Import this file at the very top of your entry point (index.js),
+ * BEFORE any other imports:
+ *
+ *   import "./mindoodb-polyfills";
+ *
+ * These polyfills are required because JavaScriptCore (JSC) on iOS
+ * does not provide atob/btoa, TextDecoder/TextEncoder, or the URL API.
+ * Automerge's base64-encoded WASM module needs atob to decode itself.
+ */
+
+// ── atob / btoa ─────────────────────────────────────────────────────────
+// JSC does not provide these. Required by Automerge's base64 WASM loader.
+
+const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+function atobPolyfill(input) {
+  if (typeof input !== 'string') throw new TypeError('Expected string');
+  const str = input.replace(/[\s]/g, '');
+  if (str.length % 4 !== 0) throw new Error('Invalid base64 string');
+
+  let output = '';
+  for (let i = 0; i < str.length; i += 4) {
+    const a = base64Chars.indexOf(str.charAt(i));
+    const b = base64Chars.indexOf(str.charAt(i + 1));
+    const c = base64Chars.indexOf(str.charAt(i + 2));
+    const d = base64Chars.indexOf(str.charAt(i + 3));
+    if (a === -1 || b === -1 || c === -1 || d === -1) throw new Error('Invalid base64 character');
+    output += String.fromCharCode((a << 2) | (b >> 4));
+    if (c !== 64) output += String.fromCharCode(((b & 15) << 4) | (c >> 2));
+    if (d !== 64) output += String.fromCharCode(((c & 3) << 6) | d);
+  }
+  return output;
+}
+
+function btoaPolyfill(input) {
+  if (typeof input !== 'string') throw new TypeError('Expected string');
+  let output = '';
+  for (let i = 0; i < input.length; i += 3) {
+    const a = input.charCodeAt(i);
+    const b = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
+    const c = i + 2 < input.length ? input.charCodeAt(i + 2) : 0;
+    output += base64Chars.charAt(a >> 2);
+    output += base64Chars.charAt(((a & 3) << 4) | (b >> 4));
+    output += i + 1 < input.length ? base64Chars.charAt(((b & 15) << 2) | (c >> 6)) : '=';
+    output += i + 2 < input.length ? base64Chars.charAt(c & 63) : '=';
+  }
+  return output;
+}
+
+if (typeof global.atob === 'undefined') global.atob = atobPolyfill;
+if (typeof global.btoa === 'undefined') global.btoa = btoaPolyfill;
+if (typeof globalThis !== 'undefined') {
+  if (typeof globalThis.atob === 'undefined') globalThis.atob = atobPolyfill;
+  if (typeof globalThis.btoa === 'undefined') globalThis.btoa = btoaPolyfill;
+}
+if (typeof window !== 'undefined') {
+  if (typeof window.atob === 'undefined') window.atob = atobPolyfill;
+  if (typeof window.btoa === 'undefined') window.btoa = btoaPolyfill;
+}
+
+// ── Crypto ──────────────────────────────────────────────────────────────
+// expo-standard-web-crypto provides getRandomValues; react-native-quick-crypto
+// provides the full Web Crypto API (including subtle) via NitroModules.
+
+import { polyfillWebCrypto } from 'expo-standard-web-crypto';
+
+try {
+  const quickCrypto = require('react-native-quick-crypto');
+  if (typeof quickCrypto.install === 'function') {
+    quickCrypto.install();
+  }
+} catch (_) {
+  // react-native-quick-crypto not available — MindooDB will fall back to JS crypto
+}
+
+if (typeof window !== 'undefined') {
+  polyfillWebCrypto();
+}
+
+// Ensure crypto is reachable on all global objects
+if (typeof crypto !== 'undefined') {
+  if (typeof window !== 'undefined' && !window.crypto) window.crypto = crypto;
+  if (typeof global !== 'undefined' && !global.crypto) global.crypto = crypto;
+  if (typeof globalThis !== 'undefined' && !globalThis.crypto) globalThis.crypto = crypto;
+}
+
+// ── TextDecoder / TextEncoder ───────────────────────────────────────────
+// Required before URL polyfill (whatwg-url needs TextDecoder).
+
+try {
+  const textEncoding = require('text-encoding');
+  if (textEncoding.TextDecoder) {
+    global.TextDecoder = textEncoding.TextDecoder;
+    global.TextEncoder = textEncoding.TextEncoder;
+    if (typeof globalThis !== 'undefined') {
+      globalThis.TextDecoder = textEncoding.TextDecoder;
+      globalThis.TextEncoder = textEncoding.TextEncoder;
+    }
+    if (typeof window !== 'undefined') {
+      window.TextDecoder = textEncoding.TextDecoder;
+      window.TextEncoder = textEncoding.TextEncoder;
+    }
+  }
+} catch (e) {
+  console.error('MindooDB: Failed to load text-encoding polyfill:', e.message);
+}
+
+// ── URL ─────────────────────────────────────────────────────────────────
+try {
+  require('react-native-url-polyfill/auto');
+} catch (_) {
+  // URL polyfill not available — may not be needed depending on usage
+}