@granular-software/sdk 0.4.16 → 0.4.17

package/dist/index.mjs

@@ -11815,6 +11815,70 @@ var Environment = class extends Session {
       await this._runGraphql(mutation.query, mutation.label);
     }
   }
+  async _ensureWorkspaceStreamsRoot() {
+    await this._runGraphql(
+      `mutation { create_model(path: "workspace", label: "workspace") { model { path } } }`,
+      "ensure workspace"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    await this._runGraphql(
+      `mutation { at(path: "workspace") { create_submodel(subpath: "streams", label: "Streams") { model { path } } } }`,
+      "ensure workspace:streams"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+  }
+  async _applyEventStreamDeclaration(stream) {
+    await this._ensureWorkspaceStreamsRoot();
+    const streamPath = `workspace:streams:${stream.name}`;
+    await this._runGraphql(
+      `mutation { at(path: "workspace:streams") { create_submodel(subpath: ${JSON.stringify(stream.name)}, label: ${JSON.stringify(stream.name)}) { model { path } } } }`,
+      `create stream ${stream.name}`
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    if (stream.description) {
+      await this._runGraphql(
+        `mutation { at(path: ${JSON.stringify(streamPath)}) { set_description(description: ${JSON.stringify(stream.description)}) { done } } }`,
+        `set stream description on ${streamPath}`
+      );
+    }
+    for (const eventType of stream.eventTypes) {
+      const typePath = `${streamPath}:${eventType.name}`;
+      await this._runGraphql(
+        `mutation { at(path: ${JSON.stringify(streamPath)}) { create_submodel(subpath: ${JSON.stringify(eventType.name)}, label: ${JSON.stringify(eventType.name)}) { model { path } } } }`,
+        `create event type ${eventType.name} on ${streamPath}`
+      ).catch((error) => {
+        if (!error.message.includes("already exists")) throw error;
+      });
+      if (eventType.description) {
+        await this._runGraphql(
+          `mutation { at(path: ${JSON.stringify(typePath)}) { set_description(description: ${JSON.stringify(eventType.description)}) { done } } }`,
+          `set event type description on ${typePath}`
+        );
+      }
+      if (eventType.payloadSchema?.properties) {
+        const fieldSpecs = {};
+        for (const [propName, propSchema] of Object.entries(eventType.payloadSchema.properties)) {
+          const schema = propSchema;
+          fieldSpecs[propName] = {
+            type: schema.type ?? "string",
+            description: schema.description
+          };
+        }
+        await this._applyFields(typePath, fieldSpecs);
+      }
+      if (eventType.payloadSchema?.required?.length) {
+        await this._runGraphql(
+          `mutation { at(path: ${JSON.stringify(typePath)}) { create_submodel(subpath: "required", label: "required") { set_string_value(value: ${JSON.stringify(JSON.stringify(eventType.payloadSchema.required))}) { done } } } }`,
+          `store required fields on ${typePath}`
+        ).catch((error) => {
+          if (!error.message.includes("already exists")) throw error;
+        });
+      }
+    }
+  }
   async _applyEffectDeclaration(effect, aliasMap) {
     let containerPath = "workspace:tools:declared";
     if (effect.attachedClass) {
@@ -11902,6 +11966,9 @@ var Environment = class extends Session {
     if (op.withEffect) {
       await this._applyEffectDeclaration(op.withEffect, aliasMap);
     }
+    if (op.defineEventStream) {
+      await this._applyEventStreamDeclaration(op.defineEventStream);
+    }
   }
   /**
    * Apply field definitions (has) to a model via GraphQL
@@ -12874,6 +12941,107 @@ var Granular = class _Granular {
       }
     };
   }
+  /**
+   * Event stream operations: query, subscribe, and acknowledge stream events
+   */
+  get streams() {
+    return {
+      getEvents: async (params) => {
+        const sandbox = await this._resolveSandboxId(params.ontology);
+        const query = new URLSearchParams({ sandboxId: sandbox });
+        if (params.environment) query.set("environmentId", params.environment);
+        if (params.session) query.set("sessionId", params.session);
+        if (params.stream) query.set("streamName", params.stream);
+        if (params.eventTypes && params.eventTypes.length > 0) {
+          query.set("eventTypes", params.eventTypes.join(","));
+        }
+        if (params.since) query.set("since", params.since.toISOString());
+        if (params.until) query.set("until", params.until.toISOString());
+        if (params.isAcked !== void 0) query.set("isAcked", params.isAcked ? "1" : "0");
+        if (params.limit) query.set("limit", String(params.limit));
+        if (params.offset) query.set("offset", String(params.offset));
+        const result = await this.request(`/control/stream-events?${query.toString()}`);
+        return (result.items || []).map((row) => ({
+          eventId: row.event_id,
+          streamName: row.stream_name,
+          eventType: row.event_type,
+          payload: typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload,
+          environmentId: row.environment_id,
+          sessionId: row.session_id,
+          subjectId: row.subject_id,
+          source: row.source,
+          isAcked: Boolean(row.is_acked),
+          createdAt: row.created_at
+        }));
+      },
+      subscribe: (params) => {
+        const interval = params.pollIntervalMs ?? 5e3;
+        let cursor = params.since || /* @__PURE__ */ new Date();
+        let running = true;
+        const seenEventIds = /* @__PURE__ */ new Set();
+        const poll = async () => {
+          while (running) {
+            try {
+              const events = await this.streams.getEvents({
+                ontology: params.ontology,
+                stream: params.stream,
+                environment: params.environment,
+                session: params.session,
+                eventTypes: params.eventTypes,
+                since: cursor,
+                limit: 100
+              });
+              const orderedEvents = [...events].sort((a, b) => a.createdAt - b.createdAt);
+              for (const event of orderedEvents) {
+                if (seenEventIds.has(event.eventId)) {
+                  continue;
+                }
+                seenEventIds.add(event.eventId);
+                const eventTime = new Date(event.createdAt * 1e3);
+                if (eventTime > cursor) {
+                  cursor = eventTime;
+                }
+                params.onEvent(event);
+              }
+            } catch (err) {
+              params.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+            await new Promise((resolve) => setTimeout(resolve, interval));
+          }
+        };
+        poll();
+        return { unsubscribe: () => {
+          running = false;
+        } };
+      },
+      ack: async (eventId) => {
+        await this.request("/control/stream-events/ack", {
+          method: "POST",
+          body: JSON.stringify({ eventIds: [eventId] })
+        });
+      },
+      ackBatch: async (eventIds) => {
+        await this.request("/control/stream-events/ack", {
+          method: "POST",
+          body: JSON.stringify({ eventIds })
+        });
+      },
+      getStats: async (params) => {
+        const sandbox = await this._resolveSandboxId(params.ontology);
+        const query = new URLSearchParams({ sandboxId: sandbox });
+        if (params.environment) query.set("environmentId", params.environment);
+        const result = await this.request(`/control/stream-events/stats?${query.toString()}`);
+        return (result.items || []).map((row) => ({
+          streamName: row.stream_name,
+          eventType: row.event_type,
+          total: Number(row.total),
+          last1h: Number(row.last_1h),
+          last24h: Number(row.last_24h),
+          unacked: Number(row.unacked)
+        }));
+      }
+    };
+  }
   /**
    * Subject management
    */
@@ -12907,6 +13075,12 @@ var Granular = class _Granular {
       }
     };
   }
+  async _resolveSandboxId(ontologyNameOrId) {
+    if (ontologyNameOrId.startsWith("sbx_")) return ontologyNameOrId;
+    const result = await this.request(`/control/sandboxes?name=${encodeURIComponent(ontologyNameOrId)}`);
+    if (result.items.length === 0) throw new Error(`Ontology not found: ${ontologyNameOrId}`);
+    return result.items[0].sandboxId;
+  }
   /**
    * Make an authenticated API request
    */