@arronqzy/vue-blueprint 0.1.8 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arronqzy/vue-blueprint",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Vue 3 blueprint editor for Abuilder (Vue Flow + Ant Design Vue)",
   "license": "MIT",
   "type": "module",
@@ -19,9 +19,9 @@
     "ant-design-vue": "^4.2.6",
     "dayjs": "^1.11.13",
     "vue": "^3.5.13",
+    "@arronqzy/blueprint-dsl": "1.0.11",
     "@arronqzy/i18n": "0.1.8",
-    "@arronqzy/vue-rx-store": "0.1.3",
-    "@arronqzy/blueprint-dsl": "1.0.10"
+    "@arronqzy/vue-rx-store": "0.1.3"
   },
   "peerDependencies": {
     "vue": "^3.4.0"
@@ -31,8 +31,8 @@
     "eslint": "^8.57.0",
     "typescript": "^5.5.4",
     "vue-tsc": "^2.2.0",
-    "@arronqzy/typescript-config": "1.0.0",
-    "@arronqzy/eslint-config": "0.0.0"
+    "@arronqzy/eslint-config": "0.0.0",
+    "@arronqzy/typescript-config": "1.0.0"
   },
   "publishConfig": {
     "access": "public"

package/src/composables/useBlueprintDebugSession.ts

@@ -41,6 +41,7 @@ export type UseBlueprintDebugSessionOptions = {
   libraryNameById?: MaybeRefOrGetter<ReadonlyMap<string, string> | undefined>;
   onExecutionBlocked?: (message: string) => void;
   onViewScopeUpdate?: (viewElementIds: string[], scope: unknown) => void;
+  nameSpace?: MaybeRefOrGetter<string | null | undefined>;
 };
 
 function buildNodeLabelMap(graph: BlueprintGraph): Record<string, string> {
@@ -63,13 +64,20 @@ export function useBlueprintDebugSession(options: UseBlueprintDebugSessionOption
   const chainComplete = ref(false);
   const logPanelOpen = ref(false);
   const running = ref(false);
-  const settings = ref<ExecutionLogSettings>(readExecutionLogSettings());
+  const settings = ref<ExecutionLogSettings>(
+    readExecutionLogSettings(toValue(options.nameSpace))
+  );
   const savedRuns = ref<ExecutionRunRecord[]>([]);
   const totalSavedRunCount = ref(0);
 
   const graph = computed(() => toValue(options.graph));
   const blueprintId = computed(() => toValue(options.blueprintId));
   const blueprintName = computed(() => toValue(options.blueprintName));
+  const nameSpace = computed(() => toValue(options.nameSpace) ?? null);
+
+  watch(nameSpace, (ns) => {
+    settings.value = readExecutionLogSettings(ns);
+  });
 
   const lifecycleNodes = computed<LifecycleNodeOption[]>(() =>
     graph.value.document.nodes
@@ -145,7 +153,7 @@ export function useBlueprintDebugSession(options: UseBlueprintDebugSessionOption
   }
 
   async function refreshSavedRuns() {
-    const all = await listExecutionRunRecords();
+    const all = await listExecutionRunRecords(undefined, nameSpace.value);
     totalSavedRunCount.value = all.length;
     savedRuns.value = blueprintId.value
       ? all.filter((item) => item.blueprintId === blueprintId.value)
@@ -158,13 +166,13 @@ export function useBlueprintDebugSession(options: UseBlueprintDebugSessionOption
 
   async function enforceSavedRunLimits() {
     const cutoff = retentionCutoffMs(settings.value.retentionDays);
-    await purgeExecutionRunsOlderThan(cutoff);
-    await trimExecutionRunRecordsToMax(settings.value.maxSavedRuns);
+    await purgeExecutionRunsOlderThan(cutoff, nameSpace.value);
+    await trimExecutionRunRecordsToMax(settings.value.maxSavedRuns, nameSpace.value);
     await refreshSavedRuns();
   }
 
   async function clearAllSavedRuns() {
-    const removed = await clearAllExecutionRunRecords();
+    const removed = await clearAllExecutionRunRecords(nameSpace.value);
     savedRuns.value = [];
     totalSavedRunCount.value = 0;
     return removed;
@@ -194,7 +202,7 @@ export function useBlueprintDebugSession(options: UseBlueprintDebugSessionOption
 
   async function persistRunIfNeeded(record: ExecutionRunRecord) {
     if (!settings.value.autoSave) return;
-    await putExecutionRunRecord(record);
+    await putExecutionRunRecord(record, nameSpace.value);
     await enforceSavedRunLimits();
   }
 
@@ -356,7 +364,7 @@ export function useBlueprintDebugSession(options: UseBlueprintDebugSessionOption
       runnerRef.value?.isDebugQueueEmpty() ? "completed" : "paused",
       entries.value
     );
-    await putExecutionRunRecord(record);
+    await putExecutionRunRecord(record, nameSpace.value);
     await enforceSavedRunLimits();
   }
 
@@ -373,10 +381,10 @@ export function useBlueprintDebugSession(options: UseBlueprintDebugSessionOption
   function updateSettings(patch: Partial<ExecutionLogSettings>) {
     const next = { ...settings.value, ...patch };
     settings.value = next;
-    writeExecutionLogSettings(next);
+    writeExecutionLogSettings(next, nameSpace.value);
     if (patch.maxSavedRuns !== undefined) {
       const maxSavedRuns = Math.max(1, Math.floor(patch.maxSavedRuns));
-      void trimExecutionRunRecordsToMax(maxSavedRuns).then(() => refreshSavedRuns());
+      void trimExecutionRunRecordsToMax(maxSavedRuns, nameSpace.value).then(() => refreshSavedRuns());
     }
   }
 

package/src/graph/index.ts

@@ -1,4 +1,5 @@
 export * from "./document";
+export * from "./parse-blueprint-data";
 export * from "./node-types";
 export * from "./blueprint-graph";
 export * from "./vue-flow-adapter";

package/src/graph/parse-blueprint-data.ts

@@ -0,0 +1,106 @@
+import {
+  sanitizeBlueprintDocument,
+  type BlueprintDocument,
+  type BlueprintGraphEdge,
+  type BlueprintGraphNode,
+  type BlueprintNodeRole,
+} from "./document";
+
+export type ParseCheckResult = {
+  ok: boolean;
+  error?: string;
+};
+
+const NODE_ROLES = new Set<BlueprintNodeRole>([
+  "blueprint",
+  "logic",
+  "and",
+  "lifecycle",
+  "fetch",
+  "json",
+  "storage",
+  "clock",
+  "event",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function extractBlueprintDocument(data: unknown): unknown {
+  if (!isRecord(data)) return data;
+  if (isRecord(data.blueprintDocument)) return data.blueprintDocument;
+  if (isRecord(data.document) && Array.isArray(data.document.nodes)) {
+    return data.document;
+  }
+  return data;
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function isBlueprintNode(value: unknown): value is BlueprintGraphNode {
+  if (!isRecord(value)) return false;
+  if (typeof value.id !== "string" || !value.id) return false;
+  if (typeof value.role !== "string" || !NODE_ROLES.has(value.role as BlueprintNodeRole)) {
+    return false;
+  }
+  if (!isRecord(value.position) || !isFiniteNumber(value.position.x) || !isFiniteNumber(value.position.y)) {
+    return false;
+  }
+  return true;
+}
+
+function isBlueprintEdge(value: unknown): value is BlueprintGraphEdge {
+  if (!isRecord(value)) return false;
+  return (
+    typeof value.id === "string" &&
+    value.id.length > 0 &&
+    typeof value.source === "string" &&
+    value.source.length > 0 &&
+    typeof value.target === "string" &&
+    value.target.length > 0
+  );
+}
+
+/**
+ * 校验数据能否被蓝图解析（工作区 `blueprintDocument`、蓝图导出 JSON 或裸文档均可）。
+ */
+export function parseBlueprintData(
+  data: unknown
+): ParseCheckResult & { value?: BlueprintDocument } {
+  if (data == null) {
+    return { ok: false, error: "empty" };
+  }
+  const raw = extractBlueprintDocument(data);
+  if (!isRecord(raw)) {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+  if (!Array.isArray(raw.nodes) || !Array.isArray(raw.edges)) {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+  if (!raw.nodes.every(isBlueprintNode) || !raw.edges.every(isBlueprintEdge)) {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+  try {
+    const value = sanitizeBlueprintDocument({
+      id: typeof raw.id === "string" && raw.id ? raw.id : "default",
+      name: typeof raw.name === "string" ? raw.name : undefined,
+      nodes: raw.nodes as BlueprintGraphNode[],
+      edges: raw.edges as BlueprintGraphEdge[],
+      allowFalseSignalPropagation:
+        typeof raw.allowFalseSignalPropagation === "boolean"
+          ? raw.allowFalseSignalPropagation
+          : undefined,
+    });
+    return { ok: true, value };
+  } catch {
+    return { ok: false, error: "invalid-blueprint-data" };
+  }
+}
+
+export function validateBlueprintData(data: unknown): ParseCheckResult {
+  const parsed = parseBlueprintData(data);
+  return parsed.ok ? { ok: true } : { ok: false, error: parsed.error };
+}

package/src/library/blueprint-library-db.ts

@@ -1,3 +1,4 @@
+import { appStorageKey } from "@arronqzy/blueprint-dsl";
 import type {
   BlueprintLibraryListItem,
   BlueprintLibraryRecord,
@@ -7,9 +8,9 @@ const DB_NAME = "arronqzy-blueprint-library";
 const DB_VERSION = 1;
 const STORE_NAME = "blueprints";
 
-function openDb(): Promise<IDBDatabase> {
+function openDb(nameSpace?: string | null): Promise<IDBDatabase> {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    const request = indexedDB.open(appStorageKey(DB_NAME, nameSpace), DB_VERSION);
     request.onerror = () => reject(request.error ?? new Error("indexeddb-open-failed"));
     request.onupgradeneeded = () => {
       const db = request.result;
@@ -25,9 +26,10 @@ function openDb(): Promise<IDBDatabase> {
 
 function runTransaction<T>(
   mode: IDBTransactionMode,
-  runner: (store: IDBObjectStore) => IDBRequest<T>
+  runner: (store: IDBObjectStore) => IDBRequest<T>,
+  nameSpace?: string | null
 ): Promise<T> {
-  return openDb().then(
+  return openDb(nameSpace).then(
     (db) =>
       new Promise<T>((resolve, reject) => {
         const tx = db.transaction(STORE_NAME, mode);
@@ -53,9 +55,13 @@ function runTransaction<T>(
   );
 }
 
-export async function listBlueprintLibrary(): Promise<BlueprintLibraryListItem[]> {
-  const records = await runTransaction<BlueprintLibraryRecord[]>("readonly", (store) =>
-    store.getAll()
+export async function listBlueprintLibrary(
+  nameSpace?: string | null
+): Promise<BlueprintLibraryListItem[]> {
+  const records = await runTransaction<BlueprintLibraryRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   return records
     .map((record) => ({
@@ -69,26 +75,31 @@ export async function listBlueprintLibrary(): Promise<BlueprintLibraryListItem[]
 }
 
 export async function getBlueprintLibraryRecord(
-  id: string
+  id: string,
+  nameSpace?: string | null
 ): Promise<BlueprintLibraryRecord | null> {
-  const record = await runTransaction<BlueprintLibraryRecord | undefined>("readonly", (store) =>
-    store.get(id)
+  const record = await runTransaction<BlueprintLibraryRecord | undefined>(
+    "readonly",
+    (store) => store.get(id),
+    nameSpace
   );
   return record ?? null;
 }
 
 export async function putBlueprintLibraryRecord(
-  record: BlueprintLibraryRecord
+  record: BlueprintLibraryRecord,
+  nameSpace?: string | null
 ): Promise<BlueprintLibraryRecord> {
-  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record));
+  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record), nameSpace);
   return record;
 }
 
 export async function updateBlueprintLibraryMeta(
   id: string,
-  patch: { name?: string; remark?: string }
+  patch: { name?: string; remark?: string },
+  nameSpace?: string | null
 ): Promise<BlueprintLibraryRecord | null> {
-  const existing = await getBlueprintLibraryRecord(id);
+  const existing = await getBlueprintLibraryRecord(id, nameSpace);
   if (!existing) return null;
 
   const name = patch.name?.trim() || existing.name;
@@ -103,10 +114,13 @@ export async function updateBlueprintLibraryMeta(
     },
   };
 
-  await putBlueprintLibraryRecord(record);
+  await putBlueprintLibraryRecord(record, nameSpace);
   return record;
 }
 
-export async function deleteBlueprintLibraryRecord(id: string): Promise<void> {
-  await runTransaction<undefined>("readwrite", (store) => store.delete(id));
+export async function deleteBlueprintLibraryRecord(
+  id: string,
+  nameSpace?: string | null
+): Promise<void> {
+  await runTransaction<undefined>("readwrite", (store) => store.delete(id), nameSpace);
 }

package/src/library/execution-log-db.ts

@@ -1,12 +1,13 @@
+import { appStorageKey } from "@arronqzy/blueprint-dsl";
 import type { ExecutionRunRecord } from "@arronqzy/blueprint-dsl";
 
 const DB_NAME = "arronqzy-blueprint-execution-log";
 const DB_VERSION = 1;
 const STORE_NAME = "runs";
 
-function openDb(): Promise<IDBDatabase> {
+function openDb(nameSpace?: string | null): Promise<IDBDatabase> {
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    const request = indexedDB.open(appStorageKey(DB_NAME, nameSpace), DB_VERSION);
     request.onerror = () => reject(request.error ?? new Error("indexeddb-open-failed"));
     request.onupgradeneeded = () => {
       const db = request.result;
@@ -22,9 +23,10 @@ function openDb(): Promise<IDBDatabase> {
 
 function runTransaction<T>(
   mode: IDBTransactionMode,
-  runner: (store: IDBObjectStore) => IDBRequest<T>
+  runner: (store: IDBObjectStore) => IDBRequest<T>,
+  nameSpace?: string | null
 ): Promise<T> {
-  return openDb().then(
+  return openDb(nameSpace).then(
     (db) =>
       new Promise<T>((resolve, reject) => {
         const tx = db.transaction(STORE_NAME, mode);
@@ -50,28 +52,55 @@ function runTransaction<T>(
   );
 }
 
+function deleteMany(ids: string[], nameSpace?: string | null): Promise<void> {
+  return openDb(nameSpace).then(
+    (db) =>
+      new Promise<void>((resolve, reject) => {
+        const tx = db.transaction(STORE_NAME, "readwrite");
+        const store = tx.objectStore(STORE_NAME);
+        for (const id of ids) {
+          store.delete(id);
+        }
+        tx.oncomplete = () => {
+          db.close();
+          resolve();
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
+        };
+      })
+  );
+}
+
 export async function putExecutionRunRecord(
-  record: ExecutionRunRecord
+  record: ExecutionRunRecord,
+  nameSpace?: string | null
 ): Promise<ExecutionRunRecord> {
-  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record));
+  await runTransaction<IDBValidKey>("readwrite", (store) => store.put(record), nameSpace);
   return record;
 }
 
 export async function getExecutionRunRecord(
-  runId: string
+  runId: string,
+  nameSpace?: string | null
 ): Promise<ExecutionRunRecord | null> {
   const record = await runTransaction<ExecutionRunRecord | undefined>(
     "readonly",
-    (store) => store.get(runId)
+    (store) => store.get(runId),
+    nameSpace
   );
   return record ?? null;
 }
 
 export async function listExecutionRunRecords(
-  blueprintId?: string | null
+  blueprintId?: string | null,
+  nameSpace?: string | null
 ): Promise<ExecutionRunRecord[]> {
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   const filtered = blueprintId
     ? records.filter((item) => item.blueprintId === blueprintId)
@@ -79,27 +108,37 @@ export async function listExecutionRunRecords(
   return filtered.sort((a, b) => b.startedAt - a.startedAt);
 }
 
-export async function deleteExecutionRunRecord(runId: string): Promise<void> {
-  await runTransaction<undefined>("readwrite", (store) => store.delete(runId));
+export async function deleteExecutionRunRecord(
+  runId: string,
+  nameSpace?: string | null
+): Promise<void> {
+  await runTransaction<undefined>("readwrite", (store) => store.delete(runId), nameSpace);
 }
 
-export async function clearAllExecutionRunRecords(): Promise<number> {
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+export async function clearAllExecutionRunRecords(
+  nameSpace?: string | null
+): Promise<number> {
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   if (records.length === 0) return 0;
 
-  await runTransaction<undefined>("readwrite", (store) => store.clear());
+  await runTransaction<undefined>("readwrite", (store) => store.clear(), nameSpace);
   return records.length;
 }
 
 export async function trimExecutionRunRecordsToMax(
-  maxCount: number
+  maxCount: number,
+  nameSpace?: string | null
 ): Promise<number> {
   if (!Number.isFinite(maxCount) || maxCount < 1) return 0;
 
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   if (records.length <= maxCount) return 0;
 
@@ -107,52 +146,29 @@ export async function trimExecutionRunRecordsToMax(
   const overflow = sorted.slice(maxCount);
   if (overflow.length === 0) return 0;
 
-  await openDb().then(
-    (db) =>
-      new Promise<void>((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, "readwrite");
-        const store = tx.objectStore(STORE_NAME);
-        for (const item of overflow) {
-          store.delete(item.runId);
-        }
-        tx.oncomplete = () => {
-          db.close();
-          resolve();
-        };
-        tx.onerror = () => {
-          db.close();
-          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
-        };
-      })
+  await deleteMany(
+    overflow.map((item) => item.runId),
+    nameSpace
   );
 
   return overflow.length;
 }
 
-export async function purgeExecutionRunsOlderThan(cutoffMs: number): Promise<number> {
-  const records = await runTransaction<ExecutionRunRecord[]>("readonly", (store) =>
-    store.getAll()
+export async function purgeExecutionRunsOlderThan(
+  cutoffMs: number,
+  nameSpace?: string | null
+): Promise<number> {
+  const records = await runTransaction<ExecutionRunRecord[]>(
+    "readonly",
+    (store) => store.getAll(),
+    nameSpace
   );
   const stale = records.filter((item) => item.startedAt < cutoffMs);
   if (stale.length === 0) return 0;
 
-  await openDb().then(
-    (db) =>
-      new Promise<void>((resolve, reject) => {
-        const tx = db.transaction(STORE_NAME, "readwrite");
-        const store = tx.objectStore(STORE_NAME);
-        for (const item of stale) {
-          store.delete(item.runId);
-        }
-        tx.oncomplete = () => {
-          db.close();
-          resolve();
-        };
-        tx.onerror = () => {
-          db.close();
-          reject(tx.error ?? new Error("indexeddb-transaction-failed"));
-        };
-      })
+  await deleteMany(
+    stale.map((item) => item.runId),
+    nameSpace
   );
 
   return stale.length;

package/src/library/execution-log-settings.ts

@@ -1,3 +1,5 @@
+import { appStorageKey } from "@arronqzy/blueprint-dsl";
+
 export type ExecutionLogSettings = {
   retentionDays: number;
   autoSave: boolean;
@@ -13,9 +15,11 @@ export const DEFAULT_EXECUTION_LOG_SETTINGS: ExecutionLogSettings = {
   maxSavedRuns: 80,
 };
 
-export function readExecutionLogSettings(): ExecutionLogSettings {
+export function readExecutionLogSettings(
+  nameSpace?: string | null
+): ExecutionLogSettings {
   try {
-    const raw = localStorage.getItem(SETTINGS_KEY);
+    const raw = localStorage.getItem(appStorageKey(SETTINGS_KEY, nameSpace));
     if (!raw) return { ...DEFAULT_EXECUTION_LOG_SETTINGS };
     const parsed = JSON.parse(raw) as Partial<ExecutionLogSettings>;
     return {
@@ -37,9 +41,15 @@ export function readExecutionLogSettings(): ExecutionLogSettings {
   }
 }
 
-export function writeExecutionLogSettings(settings: ExecutionLogSettings) {
+export function writeExecutionLogSettings(
+  settings: ExecutionLogSettings,
+  nameSpace?: string | null
+) {
   try {
-    localStorage.setItem(SETTINGS_KEY, JSON.stringify(settings));
+    localStorage.setItem(
+      appStorageKey(SETTINGS_KEY, nameSpace),
+      JSON.stringify(settings)
+    );
   } catch {
     // ignore storage errors
   }