@happyvertical/smrt-core 0.60.9 → 0.60.10

package/dist/scripts/browser-entry-evaluation.mjs

@@ -11,18 +11,28 @@
  * Set PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH to use a Chromium other than
  * Playwright's own install.
  */
+import { execFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import {
+  copyFile,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  writeFile,
+} from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import { dirname, extname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
 import { chromium } from 'playwright-core';
 import { build, createLogger } from 'vite';
 
 const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const browserEntry = resolve(packageDir, 'dist/browser.js');
 const browserHost = resolve(packageDir, 'dist/host.browser.js');
+const cascadeProbe = process.argv.includes('--pglite-cascade');
 if (!existsSync(browserEntry)) {
   throw new Error(`${browserEntry} is missing; run \`pnpm build\` first`);
 }
@@ -30,9 +40,38 @@ if (!existsSync(browserEntry)) {
 const workDir = await mkdtemp(resolve(tmpdir(), 'smrt-core-browser-entry-'));
 const outputDir = resolve(workDir, 'dist');
 const entry = resolve(workDir, 'entry.ts');
-const contentTypes = { '.js': 'text/javascript', '.map': 'application/json' };
+const contentTypes = {
+  '.js': 'text/javascript',
+  '.map': 'application/json',
+  '.wasm': 'application/wasm',
+};
+
+async function provisionPglite() {
+  const source = resolve(packageDir, 'scripts/fixtures/pglite-peer');
+  const scratch = resolve(workDir, 'pglite-peer');
+  await mkdir(scratch);
+  await Promise.all(
+    ['package.json', 'peer.js', 'pnpm-lock.yaml', 'pnpm-workspace.yaml'].map(
+      (file) => copyFile(resolve(source, file), resolve(scratch, file)),
+    ),
+  );
+  await promisify(execFile)('pnpm', [
+    '--dir',
+    scratch,
+    'install',
+    '--frozen-lockfile',
+  ]);
+
+  // Serve the peer's published ESM and WASM. Its Emscripten loader guards
+  // Node imports at runtime, but Vite warns about them when bundling the peer.
+  const { pgliteEntry } = await import(
+    pathToFileURL(resolve(scratch, 'peer.js')).href
+  );
+  return dirname(fileURLToPath(pgliteEntry));
+}
 
 try {
+  const pgliteDir = cascadeProbe ? await provisionPglite() : undefined;
   await writeFile(
     entry,
     `import * as core from ${JSON.stringify(browserEntry)};
@@ -63,7 +102,12 @@ const widget = new BrowserWidget({ name: 'probe', size: 3 });
 if (widget.name !== 'probe' || widget.size !== 3) throw new Error('widget fields were not assigned');
 const registered = ObjectRegistry.getClass('BrowserWidget');
 if (!registered) throw new Error('decorated class did not register');
-document.body.textContent = 'browser entry evaluated: ' + Object.keys(core).length + ' exports';
+${cascadeProbe ? `
+import { runPgliteCascade } from ${JSON.stringify(resolve(packageDir, 'scripts/fixtures/browser-pglite-cascade.ts'))};
+await runPgliteCascade('memory://');
+await runPgliteCascade('idb://smrt-cascade-dialect');
+document.body.textContent = 'browser entry evaluated: PGlite SET NULL cascade (memory:// and idb://)';
+` : "document.body.textContent = 'browser entry evaluated: ' + Object.keys(core).length + ' exports';"}
 `,
   );
 
@@ -89,7 +133,11 @@ document.body.textContent = 'browser entry evaluated: ' + Object.keys(core).leng
     build: {
       outDir: outputDir,
       minify: false,
-      rollupOptions: { input: entry, output: { entryFileNames: 'entry.js' } },
+      rollupOptions: {
+        input: entry,
+        ...(cascadeProbe ? { external: ['@electric-sql/pglite'] } : {}),
+        output: { entryFileNames: 'entry.js' },
+      },
       target: 'es2022',
     },
   });
@@ -103,12 +151,19 @@ document.body.textContent = 'browser entry evaluated: ' + Object.keys(core).leng
     const pathname = new URL(request.url ?? '/', 'http://localhost').pathname;
     if (pathname === '/') {
       response.writeHead(200, { 'content-type': 'text/html' });
-      response.end('<script type="module" src="/entry.js"></script>');
+      response.end(
+        (cascadeProbe
+          ? '<script type="importmap">{"imports":{"@electric-sql/pglite":"/pglite/index.js"}}</script>'
+          : '') + '<script type="module" src="/entry.js"></script>',
+      );
       return;
     }
     if (pathname === '/favicon.ico') return response.writeHead(204).end();
-    const file = resolve(outputDir, `.${pathname}`);
-    if (!file.startsWith(`${outputDir}/`)) return response.writeHead(403).end();
+    const servingPglite = pgliteDir && pathname.startsWith('/pglite/');
+    const assetDir = servingPglite ? pgliteDir : outputDir;
+    const assetPath = servingPglite ? pathname.slice('/pglite'.length) : pathname;
+    const file = resolve(assetDir, `.${assetPath}`);
+    if (!file.startsWith(`${assetDir}/`)) return response.writeHead(403).end();
     try {
       const content = await readFile(file);
       response.writeHead(200, {

package/dist/scripts/browser-unbundled-dev.mjs

@@ -15,7 +15,7 @@
  * Playwright's own install.
  */
 import { existsSync } from 'node:fs';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -28,7 +28,10 @@ if (!existsSync(namingModule)) {
   throw new Error(`${namingModule} is missing; run \`pnpm build\` first`);
 }
 
-const workDir = await mkdtemp(resolve(tmpdir(), 'smrt-core-unbundled-dev-'));
+// Vite keys inline HTML modules by their canonical path.
+const workDir = await mkdtemp(
+  resolve(await realpath(tmpdir()), 'smrt-core-unbundled-dev-'),
+);
 let server;
 let browser;
 try {

package/dist/scripts/fixtures/browser-pglite-cascade.ts

@@ -0,0 +1,107 @@
+import * as core from '../../dist/browser.js';
+import { usesPostgresDialect } from '../../dist/embedded-write-queue.js';
+import { getDatabase } from '../../dist/host.browser.js';
+
+const { SmrtObject, smrt } = core;
+
+// Exercise the complete model delete through the SDK's PGlite transaction.
+@smrt()
+class BrowserCascadeParent extends SmrtObject {}
+
+@smrt()
+class BrowserCascadeChild extends SmrtObject {
+  @core.foreignKey(BrowserCascadeParent, { onDelete: 'SET NULL' })
+  parentId;
+}
+
+export async function runPgliteCascade(dataDir: string): Promise<void> {
+  const db = await getDatabase({ type: 'pglite', dataDir });
+  try {
+    const assertEmbeddedPostgres = (handle: typeof db) => {
+      if (
+        handle.url !== dataDir ||
+        !usesPostgresDialect(handle) ||
+        !core.isEmbeddedDatabase(handle) ||
+        core.isPostgresDatabase(handle)
+      ) {
+        throw new Error(
+          'PGlite handle must use PostgreSQL syntax as an embedded database',
+        );
+      }
+    };
+    assertEmbeddedPostgres(db);
+    await db.transaction(async (tx) => assertEmbeddedPostgres(tx));
+    await core.ensureSystemTables(db, 'postgres');
+    const parent = new BrowserCascadeParent({ db, id: crypto.randomUUID() });
+    const child = new BrowserCascadeChild({ db });
+    const localDeviceId = crypto.randomUUID();
+    const trackedId = crypto.randomUUID();
+    const untrackedId = crypto.randomUUID();
+    const before = new Date(Date.now() + 86_400_000).toISOString();
+    core.setDatabaseSyncDeviceId(db, localDeviceId);
+    await db.query(`
+      CREATE TABLE ${parent.tableName} (
+        id UUID PRIMARY KEY, slug TEXT NOT NULL, context TEXT NOT NULL DEFAULT '',
+        created_at TIMESTAMP NOT NULL, updated_at TIMESTAMP NOT NULL,
+        _sync_origin_device_id TEXT, _sync_revision BIGINT
+      );
+      CREATE TABLE ${child.tableName} (
+        id UUID PRIMARY KEY, updated_at TIMESTAMP NOT NULL,
+        _sync_origin_device_id TEXT, _sync_revision BIGINT,
+        parent_id UUID REFERENCES ${parent.tableName}(id) ON DELETE SET NULL
+      );
+    `);
+    await db.query(
+      `INSERT INTO ${parent.tableName} (id, slug, created_at, updated_at)
+       VALUES ($1, 'parent', $2, $2)`,
+      parent.id,
+      before,
+    );
+    await db.query(
+      `INSERT INTO ${child.tableName}
+         (id, parent_id, updated_at, _sync_origin_device_id, _sync_revision)
+       VALUES ($1, $2, $3, 'remote', 21), ($4, $2, $3, NULL, NULL)`,
+      trackedId,
+      parent.id,
+      before,
+      untrackedId,
+    );
+
+    await parent.initialize();
+    await parent.delete();
+
+    const { rows } = await db.query(
+      `SELECT *, updated_at = $3::timestamp AS unchanged,
+          updated_at = $3::timestamp + INTERVAL '1 millisecond' AS advanced
+       FROM ${child.tableName} WHERE id IN ($1, $2)`,
+      trackedId,
+      untrackedId,
+      before,
+    );
+    const tracked = rows.find((row) => row.id === trackedId);
+    const untracked = rows.find((row) => row.id === untrackedId);
+    if (await db.get(parent.tableName, { id: parent.id })) {
+      throw new Error('PGlite cascade left the parent row');
+    }
+    if (
+      tracked?.parent_id !== null ||
+      tracked._sync_origin_device_id !== localDeviceId ||
+      Number(tracked._sync_revision) !== 22 ||
+      tracked.advanced !== true
+    ) {
+      throw new Error(
+        'PGlite SET NULL did not advance the tracked row revision',
+      );
+    }
+    if (
+      untracked?.parent_id !== null ||
+      untracked._sync_origin_device_id !== null ||
+      untracked._sync_revision !== null ||
+      untracked.unchanged !== true
+    ) {
+      throw new Error('PGlite SET NULL changed the untracked row revision');
+    }
+  } finally {
+    await db.close?.();
+  }
+}

package/dist/scripts/fixtures/pglite-peer/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "smrt-pglite-browser-peer",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@electric-sql/pglite": "0.5.15"
+  }
+}

package/dist/scripts/fixtures/pglite-peer/peer.js

@@ -0,0 +1 @@
+export const pgliteEntry = import.meta.resolve('@electric-sql/pglite');

package/dist/scripts/fixtures/pglite-peer/pnpm-lock.yaml

@@ -0,0 +1,22 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@electric-sql/pglite':
+        specifier: 0.5.15
+        version: 0.5.15
+
+packages:
+
+  '@electric-sql/pglite@0.5.15':
+    resolution: {integrity: sha512-ERZWgaRTxueGV4cvL1tfpAOzFCWTXoUtbCBqnf2FhHDVs/so9eAKaanvrwWF9Dntx7BYsmFQujVQ0/B4S8Mmiw==}
+
+snapshots:
+
+  '@electric-sql/pglite@0.5.15': {}

package/dist/scripts/fixtures/pglite-peer/pnpm-workspace.yaml

@@ -0,0 +1 @@
+packages: []