@powersync/nuxt 0.0.0-dev-20260128023420

package/dist/runtime/utils/RustClientInterceptor.js

@@ -0,0 +1,102 @@
+import {
+  AbstractPowerSyncDatabase,
+  isStreamingSyncCheckpoint,
+  isStreamingSyncCheckpointComplete,
+  isStreamingSyncCheckpointDiff,
+  isStreamingSyncCheckpointPartiallyComplete,
+  isStreamingSyncData,
+  PowerSyncControlCommand,
+  SqliteBucketStorage,
+  SyncDataBucket
+} from "@powersync/web";
+export class RustClientInterceptor extends SqliteBucketStorage {
+  constructor(db, remote, schemaManager) {
+    super(db.value.database, AbstractPowerSyncDatabase.transactionMutex);
+    this.remote = remote;
+    this.schemaManager = schemaManager;
+    this.rdb = db.value.database;
+  }
+  rdb;
+  lastStartedCheckpoint = null;
+  tables = {};
+  async control(op, payload) {
+    const response = await super.control(op, payload);
+    if (op == PowerSyncControlCommand.PROCESS_TEXT_LINE) {
+      await this.processTextLine(payload);
+    } else if (op == PowerSyncControlCommand.PROCESS_BSON_LINE) {
+      await this.processBinaryLine(payload);
+    }
+    return response;
+  }
+  processTextLine(line) {
+    return this.processParsedLine(JSON.parse(line));
+  }
+  async processBinaryLine(line) {
+    const bson = await this.remote.getBSON();
+    await this.processParsedLine(bson.deserialize(line));
+  }
+  async processParsedLine(line) {
+    if (isStreamingSyncCheckpoint(line)) {
+      this.lastStartedCheckpoint = line.checkpoint;
+      await this.trackCheckpoint(line.checkpoint);
+    } else if (isStreamingSyncCheckpointDiff(line) && this.lastStartedCheckpoint) {
+      const diff = line.checkpoint_diff;
+      const newBuckets = /* @__PURE__ */ new Map();
+      for (const checksum of this.lastStartedCheckpoint.buckets) {
+        newBuckets.set(checksum.bucket, checksum);
+      }
+      for (const checksum of diff.updated_buckets) {
+        newBuckets.set(checksum.bucket, checksum);
+      }
+      for (const bucket of diff.removed_buckets) {
+        newBuckets.delete(bucket);
+      }
+      const newCheckpoint = {
+        last_op_id: diff.last_op_id,
+        buckets: [...newBuckets.values()],
+        write_checkpoint: diff.write_checkpoint
+      };
+      this.lastStartedCheckpoint = newCheckpoint;
+      await this.trackCheckpoint(newCheckpoint);
+    } else if (isStreamingSyncData(line)) {
+      const batch = { buckets: [SyncDataBucket.fromRow(line.data)] };
+      await this.rdb.writeTransaction(async (tx) => {
+        for (const bucket of batch.buckets) {
+          const size = JSON.stringify(bucket.data).length;
+          await tx.execute(
+            `UPDATE local_bucket_data SET
+                download_size = IFNULL(download_size, 0) + ?,
+                last_op = ?,
+                downloading = ?,
+                downloaded_operations = IFNULL(downloaded_operations, 0) + ?
+              WHERE id = ?`,
+            [size, bucket.next_after, bucket.has_more, bucket.data.length, bucket.bucket]
+          );
+        }
+      });
+      await this.schemaManager.value.updateFromOperations(batch);
+    } else if (isStreamingSyncCheckpointPartiallyComplete(line) || isStreamingSyncCheckpointComplete(line)) {
+      setTimeout(() => {
+        this.schemaManager.value.refreshSchema(this.rdb);
+      }, 60);
+    }
+  }
+  async trackCheckpoint(checkpoint) {
+    await this.rdb.writeTransaction(async (tx) => {
+      for (const bucket of checkpoint.buckets) {
+        await tx.execute(
+          `INSERT OR REPLACE INTO local_bucket_data(id, total_operations, last_op, download_size, downloading, downloaded_operations)
+               VALUES (
+                ?,
+                ?,
+                IFNULL((SELECT last_op FROM local_bucket_data WHERE id = ?), '0'),
+                IFNULL((SELECT download_size FROM local_bucket_data WHERE id = ?), 0),
+                IFNULL((SELECT downloading FROM local_bucket_data WHERE id = ?), TRUE),
+                IFNULL((SELECT downloaded_operations FROM local_bucket_data WHERE id = ?), TRUE)
+                )`,
+          [bucket.bucket, bucket.count, bucket.bucket, bucket.bucket, bucket.bucket, bucket.bucket]
+        );
+      }
+    });
+  }
+}

package/dist/runtime/utils/TokenConnector.d.ts

@@ -0,0 +1,14 @@
+import type { AbstractPowerSyncDatabase, PowerSyncBackendConnector } from '@powersync/web';
+export interface Credentials {
+    token: string;
+    endpoint: string;
+}
+export declare class TokenConnector implements PowerSyncBackendConnector {
+    private connectFn?;
+    setConnectFunction(connectFn: () => Promise<void>): void;
+    fetchCredentials(): any;
+    uploadData(database: AbstractPowerSyncDatabase): Promise<void>;
+    signIn(credentials: Credentials): Promise<void>;
+    hasCredentials(): boolean;
+    clearCredentials(): void;
+}

package/dist/runtime/utils/TokenConnector.js

@@ -0,0 +1,62 @@
+export class TokenConnector {
+  connectFn;
+  // Inject the connect function to avoid circular dependency
+  setConnectFunction(connectFn) {
+    this.connectFn = connectFn;
+  }
+  fetchCredentials() {
+    const value = localStorage.getItem("powersync_credentials");
+    if (value == null) {
+      return null;
+    }
+    return JSON.parse(value);
+  }
+  async uploadData(database) {
+    const tx = await database.getNextCrudTransaction();
+    await tx?.complete();
+  }
+  async signIn(credentials) {
+    validateSecureContext(credentials.endpoint);
+    checkJWT(credentials.token);
+    try {
+      localStorage.setItem(
+        "powersync_credentials",
+        JSON.stringify(credentials)
+      );
+      await this.connectFn();
+    } catch (e) {
+      this.clearCredentials();
+      throw e;
+    }
+  }
+  hasCredentials() {
+    return localStorage.getItem("powersync_credentials") != null;
+  }
+  clearCredentials() {
+    localStorage.removeItem("powersync_credentials");
+  }
+}
+function validateSecureContext(url) {
+  if (!location.href.startsWith("https:")) {
+    return;
+  }
+  const parsedUrl = new URL(url);
+  const secure = parsedUrl.protocol === "https:" || parsedUrl.hostname === "localhost" || parsedUrl.hostname === "127.0.0.1" || parsedUrl.hostname === "::1";
+  if (!secure) {
+    throw new Error(`Cannot connect to http endpoints from the hosted diagnostics app.
+Run either the PowerSync endpoint on http://localhost, or the diagnostics app on http://localhost.`);
+  }
+}
+function checkJWT(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error(
+      `Token must be a JWT: Expected 3 parts, got ${parts.length}`
+    );
+  }
+  const base64UrlRegex = /^[\w-]+$/;
+  const isBase64 = parts.every((part) => base64UrlRegex.test(part));
+  if (!isBase64) {
+    throw new Error(`Token must be a JWT: Not all parts are base64 encoded`);
+  }
+}

package/dist/runtime/utils/addImportsFrom.d.ts

@@ -0,0 +1 @@
+export declare const addImportsFrom: (names: string[], from: string) => void;

package/dist/runtime/utils/addImportsFrom.js

@@ -0,0 +1,4 @@
+import { addImports } from "@nuxt/kit";
+export const addImportsFrom = (names, from) => {
+  addImports(names.map((name) => ({ name, from })));
+};

package/dist/runtime/utils/index.d.ts

@@ -0,0 +1 @@
+export { NuxtPowerSyncDatabase } from './NuxtPowerSyncDatabase.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1 @@
+export { NuxtPowerSyncDatabase } from "./NuxtPowerSyncDatabase.js";

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'
+
+export { type PowerSyncNuxtModuleOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@powersync/nuxt",
+  "version": "0.0.0-dev-20260128023420",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "description": "PowerSync Nuxt module",
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/powersync-ja/powersync-js.git"
+  },
+  "author": "POWERSYNC",
+  "bugs": {
+    "url": "https://github.com/powersync-ja/powersync-js/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://docs.powersync.com",
+  "dependencies": {
+    "@iconify-json/carbon": "^1.2.13",
+    "@nuxt/devtools-kit": "^2.6.2",
+    "@nuxt/devtools-ui-kit": "^2.6.2",
+    "@nuxt/kit": "^4.0.3",
+    "@tanstack/vue-table": "^8.21.3",
+    "@vueuse/nuxt": "^13.9.0",
+    "consola": "^3.4.2",
+    "defu": "^6.1.4",
+    "fuse.js": "^7.1.0",
+    "mitt": "^3.0.1",
+    "reka-ui": "^2.5.0",
+    "shiki": "^3.13.0",
+    "unocss": "^66.5.2",
+    "unstorage": "^1.17.1"
+  },
+  "peerDependencies": {
+    "@journeyapps/wa-sqlite": "^1.2.6",
+    "@powersync/kysely-driver": "0.0.0-dev-20260128023420",
+    "@powersync/vue": "0.4.1",
+    "@powersync/web": "0.0.0-dev-20260128023420"
+  },
+  "peerDependenciesMeta": {
+    "@powersync/kysely-driver": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@journeyapps/wa-sqlite": "^1.4.0",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.1.2",
+    "@nuxt/test-utils": "^3.19.2",
+    "nuxt": "^4.1.2",
+    "vite-plugin-wasm": "^3.5.0",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.20",
+    "vue-tsc": "^3.0.8",
+    "@powersync/kysely-driver": "0.0.0-dev-20260128023420",
+    "@powersync/vue": "0.4.1",
+    "@powersync/web": "0.0.0-dev-20260128023420"
+  },
+  "scripts": {
+    "prebuild": "nuxt-module-build prepare",
+    "build": "nuxt-module-build build",
+    "prebuild:prod": "nuxt-module-build prepare",
+    "build:prod": "nuxt-module-build build",
+    "clean": "rm -rf dist .nuxt",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
+    "watch": "nuxt-module-build build --watch",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:exports": "attw --pack --profile=esm-only ."
+  }
+}