@noy-db/in-pinia 0.1.0-pre.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vLannaAi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# @noy-db/in-pinia
+
+> Pinia integration for [noy-db](https://github.com/vLannaAi/noy-db) — drop-in encrypted Pinia stores for Vue 3 / Nuxt 4.
+
+```bash
+pnpm add @noy-db/in-pinia @noy-db/hub pinia vue
+# pick an adapter for your environment:
+pnpm add @noy-db/to-file       # local disk / USB
+pnpm add @noy-db/to-browser-idb    # localStorage / IndexedDB
+pnpm add @noy-db/to-aws-dynamo     # AWS DynamoDB
+```
+
+## Quick start
+
+```ts
+// stores/invoices.ts
+import { defineNoydbStore } from '@noy-db/in-pinia';
+
+interface Invoice {
+  id: string;
+  amount: number;
+  status: 'draft' | 'open' | 'paid';
+  client: string;
+}
+
+export const useInvoices = defineNoydbStore<Invoice>('invoices', {
+  compartment: 'C101',
+});
+```
+
+```ts
+// main.ts
+import { createApp } from 'vue';
+import { createPinia } from 'pinia';
+import { createNoydb } from '@noy-db/hub';
+import { jsonFile } from '@noy-db/to-file';
+import { setActiveNoydb } from '@noy-db/in-pinia';
+import App from './App.vue';
+
+const db = await createNoydb({
+  adapter: jsonFile({ dir: './data' }),
+  user: 'owner',
+  secret: () => prompt('Passphrase')!,
+});
+
+setActiveNoydb(db);
+
+createApp(App).use(createPinia()).mount('#app');
+```
+
+```vue
+<!-- App.vue -->
+<script setup lang="ts">
+import { useInvoices } from './stores/invoices';
+
+const invoices = useInvoices();
+await invoices.$ready;
+
+async function addOne() {
+  const id = `inv-${Date.now()}`;
+  await invoices.add(id, { id, amount: 100, status: 'draft', client: 'Acme' });
+}
+</script>
+
+<template>
+  <div>
+    <button @click="addOne">Add invoice</button>
+    <p>{{ invoices.count }} invoices</p>
+    <ul>
+      <li v-for="inv in invoices.items" :key="inv.id">
+        {{ inv.client }} — {{ inv.amount }} — {{ inv.status }}
+      </li>
+    </ul>
+  </div>
+</template>
+```
+
+## Store API
+
+Every store returned by `defineNoydbStore` exposes:
+
+| Member | Type | Purpose |
+|---|---|---|
+| `items` | `Ref<T[]>` | Reactive array of all decrypted records |
+| `count` | `ComputedRef<number>` | Reactive count |
+| `$ready` | `Promise<void>` | Resolves once the collection has hydrated on first use |
+| `byId(id)` | `(id) => T \| undefined` | O(N) cache lookup |
+| `add(id, record)` | `async (id, T) => void` | Encrypt + persist + update reactive state |
+| `update(id, record)` | `async (id, T) => void` | Alias for `add` (NOYDB `put` is upsert) |
+| `remove(id)` | `async (id) => void` | Delete + update reactive state |
+| `refresh()` | `async () => void` | Re-hydrate from the adapter (use after sync pulls) |
+| `query()` | `() => Query<T>` | Chainable query DSL — see `@noy-db/hub` |
+
+## Composition
+
+The store is a real Pinia store. All these work unmodified:
+
+- `storeToRefs(store)` — destructure with reactivity intact
+- Vue Devtools — appears in the devtools tab like any other store
+- SSR — `items` is empty during server render, hydrates on the client
+- `pinia-plugin-persistedstate` — works as a fallback layer below NOYDB encryption
+
+## Schema validation
+
+Pass any object exposing `parse(input): T` (Zod, Valibot, ArkType, Effect Schema, etc.):
+
+```ts
+import { z } from 'zod';
+
+const InvoiceSchema = z.object({
+  id: z.string(),
+  amount: z.number().positive(),
+  status: z.enum(['draft', 'open', 'paid']),
+  client: z.string(),
+});
+
+export const useInvoices = defineNoydbStore<z.infer<typeof InvoiceSchema>>('invoices', {
+  compartment: 'C101',
+  schema: InvoiceSchema,
+});
+```
+
+`add()` and `update()` will throw if the record fails validation, before any encryption or write happens.
+
+## Query DSL
+
+The store's `query()` method returns the same chainable builder as `Collection.query()`:
+
+```ts
+const overdue = invoices.query()
+  .where('status', '==', 'open')
+  .where('dueDate', '<', new Date())
+  .orderBy('dueDate', 'asc')
+  .limit(50)
+  .toArray();
+```
+
+See [`@noy-db/hub` query DSL docs](../core/README.md#query-dsl) for the full operator list.
+
+## Status
+
+See [ROADMAP.md](../../ROADMAP.md) for the forward plan.
+
+## License
+
+MIT © vLannaAi

package/dist/index.cjs

@@ -0,0 +1,443 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CAPABILITY_REQUESTS_COLLECTION: () => CAPABILITY_REQUESTS_COLLECTION,
+  createNoydbPiniaPlugin: () => createNoydbPiniaPlugin,
+  defineNoydbStore: () => defineNoydbStore,
+  getActiveNoydb: () => getActiveNoydb,
+  resolveNoydb: () => resolveNoydb,
+  setActiveNoydb: () => setActiveNoydb,
+  useCapabilityGrant: () => useCapabilityGrant
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/defineNoydbStore.ts
+var import_pinia = require("pinia");
+var import_vue = require("vue");
+
+// src/context.ts
+var activeInstance = null;
+function setActiveNoydb(instance) {
+  activeInstance = instance;
+}
+function getActiveNoydb() {
+  return activeInstance;
+}
+function resolveNoydb(explicit) {
+  if (explicit) return explicit;
+  if (activeInstance) return activeInstance;
+  throw new Error(
+    "@noy-db/pinia: no Noydb instance bound.\n  Option A \u2014 pass `noydb:` directly to defineNoydbStore({...})\n  Option B \u2014 call setActiveNoydb(instance) once at app startup\n  Option C \u2014 install the @noy-db/nuxt module (Nuxt 4+)"
+  );
+}
+
+// src/defineNoydbStore.ts
+function defineNoydbStore(id, options) {
+  const collectionName = options.collection ?? id;
+  const prefetch = options.prefetch ?? true;
+  return (0, import_pinia.defineStore)(id, () => {
+    const items = (0, import_vue.shallowRef)([]);
+    const count = (0, import_vue.computed)(() => items.value.length);
+    let cachedCompartment = null;
+    let cachedCollection = null;
+    async function getCollection() {
+      if (cachedCollection) return cachedCollection;
+      const noydb = resolveNoydb(options.noydb ?? null);
+      cachedCompartment = await noydb.openVault(options.vault);
+      const collOpts = {};
+      if (options.schema !== void 0) collOpts.schema = options.schema;
+      cachedCollection = cachedCompartment.collection(collectionName, collOpts);
+      return cachedCollection;
+    }
+    async function refresh() {
+      const c = await getCollection();
+      const list = await c.list();
+      items.value = list;
+    }
+    function byId(id2) {
+      for (const item of items.value) {
+        if (item.id === id2) return item;
+      }
+      return void 0;
+    }
+    async function add(id2, record) {
+      const c = await getCollection();
+      await c.put(id2, record);
+      items.value = await c.list();
+    }
+    async function update(id2, record) {
+      await add(id2, record);
+    }
+    async function remove(id2) {
+      const c = await getCollection();
+      await c.delete(id2);
+      items.value = await c.list();
+    }
+    function query() {
+      if (!cachedCollection) {
+        throw new Error(
+          "@noy-db/pinia: query() called before the store was ready. Await store.$ready first, or set prefetch: true (default)."
+        );
+      }
+      return cachedCollection.query();
+    }
+    function liveQuery(build) {
+      if (!cachedCollection) {
+        throw new Error(
+          "@noy-db/pinia: liveQuery() called before the store was ready. Await store.$ready first, or set prefetch: true (default)."
+        );
+      }
+      const built = build(cachedCollection.query());
+      const live = built.live();
+      const items2 = (0, import_vue.shallowRef)(live.value);
+      const error = (0, import_vue.ref)(live.error);
+      const unsubscribe = live.subscribe(() => {
+        items2.value = live.value;
+        error.value = live.error;
+      });
+      let stopped = false;
+      const stop = () => {
+        if (stopped) return;
+        stopped = true;
+        unsubscribe();
+        live.stop();
+      };
+      if ((0, import_vue.getCurrentScope)()) (0, import_vue.onScopeDispose)(stop);
+      return { items: items2, error, stop };
+    }
+    const $ready = prefetch ? refresh() : Promise.resolve();
+    return {
+      items,
+      count,
+      $ready,
+      byId,
+      add,
+      update,
+      remove,
+      refresh,
+      query,
+      liveQuery
+    };
+  });
+}
+
+// src/plugin.ts
+var import_hub = require("@noy-db/hub");
+var STATE_DOC_ID = "__state__";
+function createNoydbPiniaPlugin(opts) {
+  let dbPromise = null;
+  function getDb() {
+    if (!dbPromise) {
+      dbPromise = (async () => {
+        const secret = await opts.secret();
+        return (0, import_hub.createNoydb)({
+          store: opts.adapter,
+          user: opts.user,
+          secret,
+          ...opts.noydbOptions
+        });
+      })();
+    }
+    return dbPromise;
+  }
+  const vaultCache = /* @__PURE__ */ new Map();
+  function getCompartment(name) {
+    let p = vaultCache.get(name);
+    if (!p) {
+      p = getDb().then((db) => db.openVault(name));
+      vaultCache.set(name, p);
+    }
+    return p;
+  }
+  return (context) => {
+    const noydbOption = context.options.noydb;
+    if (!noydbOption) {
+      context.store.$noydbAugmented = false;
+      return;
+    }
+    context.store.$noydbAugmented = true;
+    context.store.$noydbError = null;
+    const pending = /* @__PURE__ */ new Set();
+    const ready = (async () => {
+      try {
+        const vault = await getCompartment(noydbOption.vault);
+        const collection = vault.collection(
+          noydbOption.collection
+        );
+        const persisted = await collection.get(STATE_DOC_ID);
+        if (persisted) {
+          const validated = noydbOption.schema ? noydbOption.schema.parse(persisted) : persisted;
+          const picked = pickKeys(validated, noydbOption.persist);
+          context.store.$patch(picked);
+        }
+        context.store.$subscribe(
+          (_mutation, state) => {
+            const subset = pickKeys(state, noydbOption.persist);
+            const p = collection.put(STATE_DOC_ID, subset).catch((err) => {
+              context.store.$noydbError = err instanceof Error ? err : new Error(String(err));
+            }).finally(() => {
+              pending.delete(p);
+            });
+            pending.add(p);
+          },
+          { detached: true }
+          // outlive the component that triggered the mutation
+        );
+      } catch (err) {
+        context.store.$noydbError = err instanceof Error ? err : new Error(String(err));
+      }
+    })();
+    context.store.$noydbReady = ready;
+    context.store.$noydbFlush = async () => {
+      await ready;
+      while (pending.size > 0) {
+        await Promise.all([...pending]);
+      }
+    };
+  };
+}
+function pickKeys(state, persist) {
+  if (persist === void 0 || persist === "*") {
+    return { ...state };
+  }
+  if (typeof persist === "string") {
+    return { [persist]: state[persist] };
+  }
+  if (Array.isArray(persist)) {
+    const out = {};
+    for (const key of persist) {
+      out[key] = state[key];
+    }
+    return out;
+  }
+  return { ...state };
+}
+
+// src/useCapabilityGrant.ts
+var import_vue2 = require("vue");
+var CAPABILITY_REQUESTS_COLLECTION = "_capability_requests";
+function useCapabilityGrant(capability, options) {
+  const state = (0, import_vue2.ref)("idle");
+  const error = (0, import_vue2.ref)(null);
+  const recordRef = (0, import_vue2.shallowRef)(null);
+  const inBrowser = typeof window !== "undefined";
+  let expiryTimer = null;
+  let unsubscribeChangeStream = null;
+  let resolvedVault = null;
+  let stopped = false;
+  async function resolveVault() {
+    if (resolvedVault) return resolvedVault;
+    if (typeof options.vault === "string") {
+      const noydb = resolveNoydb(null);
+      resolvedVault = await noydb.openVault(options.vault);
+    } else {
+      resolvedVault = options.vault;
+    }
+    resolvedVault.collection(
+      CAPABILITY_REQUESTS_COLLECTION
+    );
+    return resolvedVault;
+  }
+  function clearExpiryTimer() {
+    if (expiryTimer) {
+      clearTimeout(expiryTimer);
+      expiryTimer = null;
+    }
+  }
+  function scheduleExpiry(record) {
+    if (!record.expiresAt) return;
+    const remaining = new Date(record.expiresAt).getTime() - Date.now();
+    if (remaining <= 0) {
+      void handleExpiry(record);
+      return;
+    }
+    clearExpiryTimer();
+    expiryTimer = setTimeout(() => {
+      void handleExpiry(record);
+    }, remaining);
+  }
+  async function handleExpiry(record) {
+    if (stopped) return;
+    if (state.value !== "granted") return;
+    state.value = "expired";
+    try {
+      await options.onRelease?.({
+        record,
+        vault: resolvedVault,
+        cause: "expired"
+      });
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+    }
+    state.value = "idle";
+    recordRef.value = null;
+  }
+  const now = (0, import_vue2.ref)(Date.now());
+  const tickTimer = inBrowser ? setInterval(() => {
+    now.value = Date.now();
+  }, 1e3) : null;
+  const timeRemaining = (0, import_vue2.computed)(() => {
+    if (state.value !== "granted" || !recordRef.value?.expiresAt) return 0;
+    void now.value;
+    const ms = new Date(recordRef.value.expiresAt).getTime() - Date.now();
+    return ms > 0 ? ms : 0;
+  });
+  (0, import_vue2.watch)(
+    () => recordRef.value?.id,
+    async (id) => {
+      if (!inBrowser || !id || unsubscribeChangeStream) return;
+      const vault = await resolveVault();
+      const coll = vault.collection(
+        CAPABILITY_REQUESTS_COLLECTION
+      );
+      unsubscribeChangeStream = coll.subscribe(
+        (evt) => {
+          if (evt.type !== "put" || evt.id !== id) return;
+          const updated = evt.record;
+          if (!updated || stopped) return;
+          recordRef.value = updated;
+          if (updated.status === "granted") {
+            state.value = "granted";
+            scheduleExpiry(updated);
+          } else if (updated.status === "released" || updated.status === "expired") {
+            state.value = "idle";
+            clearExpiryTimer();
+          }
+        }
+      );
+    },
+    { immediate: false }
+  );
+  async function request() {
+    if (state.value !== "idle") {
+      error.value = new Error(
+        `useCapabilityGrant: cannot request from state "${state.value}"`
+      );
+      throw error.value;
+    }
+    error.value = null;
+    if (!inBrowser) return;
+    try {
+      const vault = await resolveVault();
+      const coll = vault.collection(
+        CAPABILITY_REQUESTS_COLLECTION
+      );
+      const id = `cap-${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 10)}`;
+      const record = {
+        id,
+        capability,
+        requestedBy: vault.userId,
+        approverRole: options.approver,
+        reason: options.reason,
+        ttlMs: options.ttlMs,
+        status: "requested",
+        requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await coll.put(id, record);
+      recordRef.value = record;
+      state.value = "requested";
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      throw error.value;
+    }
+  }
+  async function approve() {
+    const record = recordRef.value;
+    if (state.value !== "requested" || !record) {
+      error.value = new Error(
+        `useCapabilityGrant: cannot approve from state "${state.value}"`
+      );
+      throw error.value;
+    }
+    error.value = null;
+    try {
+      const vault = await resolveVault();
+      if (vault.role !== options.approver && vault.role !== "owner") {
+        throw new Error(
+          `useCapabilityGrant: caller role "${vault.role}" cannot approve a "${options.approver}"-tier grant`
+        );
+      }
+      const approvedAt = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(approvedAt.getTime() + options.ttlMs);
+      const granted = {
+        ...record,
+        status: "granted",
+        approvedBy: vault.userId,
+        approvedAt: approvedAt.toISOString(),
+        expiresAt: expiresAt.toISOString()
+      };
+      const coll = vault.collection(
+        CAPABILITY_REQUESTS_COLLECTION
+      );
+      await coll.put(record.id, granted);
+      recordRef.value = granted;
+      state.value = "granted";
+      scheduleExpiry(granted);
+      await options.onGrant?.({ record: granted, vault });
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      throw error.value;
+    }
+  }
+  async function release() {
+    const record = recordRef.value;
+    if (state.value !== "granted" || !record) {
+      return;
+    }
+    error.value = null;
+    try {
+      clearExpiryTimer();
+      const vault = await resolveVault();
+      const released = { ...record, status: "released" };
+      const coll = vault.collection(
+        CAPABILITY_REQUESTS_COLLECTION
+      );
+      await coll.put(record.id, released);
+      recordRef.value = null;
+      state.value = "idle";
+      await options.onRelease?.({ record, vault, cause: "released" });
+    } catch (err) {
+      error.value = err instanceof Error ? err : new Error(String(err));
+      throw error.value;
+    }
+  }
+  if ((0, import_vue2.getCurrentScope)()) {
+    (0, import_vue2.onScopeDispose)(() => {
+      stopped = true;
+      clearExpiryTimer();
+      if (tickTimer) clearInterval(tickTimer);
+      unsubscribeChangeStream?.();
+    });
+  }
+  return { state, timeRemaining, error, request, approve, release };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CAPABILITY_REQUESTS_COLLECTION,
+  createNoydbPiniaPlugin,
+  defineNoydbStore,
+  getActiveNoydb,
+  resolveNoydb,
+  setActiveNoydb,
+  useCapabilityGrant
+});
+//# sourceMappingURL=index.cjs.map