@synapseone/sdk 0.0.0-stage → 0.7.0-dev.43

package/dist/stream.d.ts

@@ -0,0 +1,99 @@
+import { HttpClient } from './_http';
+export interface StreamTopicConfig {
+    name: string;
+    maxLen?: number;
+    minId?: string;
+    retentionMs?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface StreamEvent<T = unknown> {
+    id: string;
+    payload: T;
+    key?: string;
+    headers?: Record<string, unknown>;
+    timestamp: number;
+}
+export interface StreamPublishInput {
+    payload: unknown;
+    key?: string;
+    headers?: Record<string, unknown>;
+    id?: string;
+}
+export interface StreamReadOptions {
+    fromId?: string;
+    count?: number;
+    blockMs?: number;
+}
+export interface StreamGroupReadOptions {
+    consumer?: string;
+    count?: number;
+    blockMs?: number;
+    autoAck?: boolean;
+}
+export interface StreamRangeOptions {
+    start?: string;
+    end?: string;
+    count?: number;
+}
+export declare class StreamService {
+    private readonly http;
+    constructor(http: HttpClient);
+    private t;
+    private g;
+    listTopics(): Promise<{
+        topics: StreamTopicConfig[];
+    }>;
+    createTopic(topic: string, opts?: {
+        maxLen?: number;
+        minId?: string;
+        retentionMs?: number;
+    }): Promise<{
+        topic: StreamTopicConfig;
+    }>;
+    getTopic(topic: string): Promise<{
+        topic: StreamTopicConfig;
+    }>;
+    deleteTopic(topic: string): Promise<{
+        deleted: boolean;
+    }>;
+    topicStats(topic: string): Promise<{
+        stats: any;
+    }>;
+    publish(topic: string, payload: unknown, opts?: {
+        key?: string;
+        headers?: Record<string, unknown>;
+        id?: string;
+    }): Promise<{
+        event: StreamEvent;
+    }>;
+    publishBatch(topic: string, events: StreamPublishInput[]): Promise<{
+        events: StreamEvent[];
+        count: number;
+    }>;
+    read(topic: string, opts?: StreamReadOptions): Promise<{
+        events: StreamEvent[];
+        count: number;
+    }>;
+    range(topic: string, opts?: StreamRangeOptions): Promise<{
+        events: StreamEvent[];
+        count: number;
+    }>;
+    createGroup(topic: string, group: string, opts?: {
+        startId?: string;
+    }): Promise<{
+        group: string;
+        topic: string;
+        startId: string;
+    }>;
+    destroyGroup(topic: string, group: string): Promise<{
+        destroyed: boolean;
+    }>;
+    readGroup(topic: string, group: string, opts?: StreamGroupReadOptions): Promise<{
+        events: StreamEvent[];
+        count: number;
+    }>;
+    ack(topic: string, group: string, ids: string[]): Promise<{
+        acked: number;
+    }>;
+}

package/dist/stream.js

@@ -0,0 +1,117 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * SynapseStream client: topics, produce (single & batch), consumer groups,
+ * non-destructive reads, time-range queries and retention trimming.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamService = void 0;
+const P = '/v1/stream/topics';
+class StreamService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    t(topic) {
+        return encodeURIComponent(topic);
+    }
+    g(group) {
+        return encodeURIComponent(group);
+    }
+    // ---- topics ----
+    listTopics() {
+        return this.http.req(P);
+    }
+    createTopic(topic, opts = {}) {
+        return this.http.req(`${P}/${this.t(topic)}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                ...(opts.maxLen !== undefined ? { maxLen: opts.maxLen } : {}),
+                ...(opts.minId !== undefined ? { minId: opts.minId } : {}),
+                ...(opts.retentionMs !== undefined ? { retentionMs: opts.retentionMs } : {}),
+            }),
+        });
+    }
+    getTopic(topic) {
+        return this.http.req(`${P}/${this.t(topic)}`);
+    }
+    deleteTopic(topic) {
+        return this.http.req(`${P}/${this.t(topic)}`, { method: 'DELETE' });
+    }
+    topicStats(topic) {
+        return this.http.req(`${P}/${this.t(topic)}/stats`);
+    }
+    // ---- publish ----
+    publish(topic, payload, opts = {}) {
+        return this.http.req(`${P}/${this.t(topic)}/events`, {
+            method: 'POST',
+            body: JSON.stringify({
+                payload,
+                ...(opts.key !== undefined ? { key: opts.key } : {}),
+                ...(opts.headers !== undefined ? { headers: opts.headers } : {}),
+                ...(opts.id !== undefined ? { id: opts.id } : {}),
+            }),
+        });
+    }
+    publishBatch(topic, events) {
+        return this.http.req(`${P}/${this.t(topic)}/events:batch`, {
+            method: 'POST',
+            body: JSON.stringify({ events }),
+        });
+    }
+    // ---- read / range ----
+    read(topic, opts = {}) {
+        return this.http.req(`${P}/${this.t(topic)}/read`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ...(opts.fromId !== undefined ? { fromId: opts.fromId } : {}),
+                ...(opts.count !== undefined ? { count: opts.count } : {}),
+                ...(opts.blockMs !== undefined ? { blockMs: opts.blockMs } : {}),
+            }),
+        });
+    }
+    range(topic, opts = {}) {
+        const qs = new URLSearchParams();
+        if (opts.start)
+            qs.set('start', opts.start);
+        if (opts.end)
+            qs.set('end', opts.end);
+        if (opts.count !== undefined)
+            qs.set('count', String(opts.count));
+        const s = qs.toString();
+        return this.http.req(`${P}/${this.t(topic)}/range${s ? `?${s}` : ''}`);
+    }
+    // ---- consumer groups ----
+    createGroup(topic, group, opts = {}) {
+        return this.http.req(`${P}/${this.t(topic)}/groups/${this.g(group)}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                ...(opts.startId !== undefined ? { startId: opts.startId } : {}),
+            }),
+        });
+    }
+    destroyGroup(topic, group) {
+        return this.http.req(`${P}/${this.t(topic)}/groups/${this.g(group)}`, {
+            method: 'DELETE',
+        });
+    }
+    readGroup(topic, group, opts = {}) {
+        return this.http.req(`${P}/${this.t(topic)}/groups/${this.g(group)}/read`, {
+            method: 'POST',
+            body: JSON.stringify({
+                consumer: opts.consumer || 'default-worker',
+                ...(opts.count !== undefined ? { count: opts.count } : {}),
+                ...(opts.blockMs !== undefined ? { blockMs: opts.blockMs } : {}),
+                ...(opts.autoAck !== undefined ? { autoAck: opts.autoAck } : {}),
+            }),
+        });
+    }
+    ack(topic, group, ids) {
+        return this.http.req(`${P}/${this.t(topic)}/groups/${this.g(group)}/ack`, {
+            method: 'POST',
+            body: JSON.stringify({ ids }),
+        });
+    }
+}
+exports.StreamService = StreamService;

package/dist/workflow.d.ts

@@ -0,0 +1,82 @@
+import { HttpClient } from './_http';
+/** Credential kinds accepted by the workflow engine (used by http/webhook nodes). */
+export type CredentialKind = 'bearer' | 'api-key' | 'basic' | 'hmac';
+export interface CredentialInput {
+    /** Owning account (credentials are account-scoped, org-bound for org callers). */
+    accountId: string;
+    name: string;
+    kind?: CredentialKind | string;
+    type?: CredentialKind | string;
+    /** Write-only: never returned by any endpoint. */
+    secret: string;
+}
+export interface CredentialMetadata {
+    id: string;
+    accountId: string;
+    name: string;
+    kind: CredentialKind | string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class WorkflowService {
+    private readonly http;
+    constructor(http: HttpClient);
+    listTemplates(): Promise<unknown>;
+    getTemplate(name: string): Promise<unknown>;
+    listWorkflows(): Promise<unknown>;
+    getWorkflow(id: string): Promise<unknown>;
+    createWorkflowFromTemplate(template: string, name?: string): Promise<unknown>;
+    createWorkflow(name: string, definition: any, settings?: Record<string, unknown>): Promise<unknown>;
+    updateWorkflow(id: string, patch: {
+        name?: string;
+        definition?: any;
+        settings?: Record<string, unknown>;
+    }): Promise<unknown>;
+    deleteWorkflow(id: string): Promise<unknown>;
+    activateWorkflow(id: string): Promise<unknown>;
+    deactivateWorkflow(id: string): Promise<unknown>;
+    executeWorkflow(id: string, payload?: Record<string, unknown>): Promise<unknown>;
+    getExecution(id: string, includeData?: boolean): Promise<unknown>;
+    listExecutions(query?: string | Record<string, string | number | boolean | undefined>): Promise<any[]>;
+    testRun(definition: any, input?: Record<string, unknown>, workflowId?: string): Promise<unknown>;
+    createCredential(inputOrAccountId: CredentialInput | string, opts?: {
+        name: string;
+        kind?: CredentialKind | string;
+        type?: CredentialKind | string;
+        secret: string;
+        expiresAt?: string;
+    }): Promise<CredentialMetadata>;
+    listCredentials(accountId?: string): Promise<CredentialMetadata[]>;
+    getCredential(id: string): Promise<CredentialMetadata>;
+    rotateCredential(id: string, secret: string): Promise<CredentialMetadata>;
+    deleteCredential(id: string): Promise<unknown>;
+    /**
+     * Fire a public inbound webhook through the gateway: `ANY /webhook/:path`.
+     * No auth is required; per-workflow auth/rate-limit/idempotency still apply.
+     * `path` is the webhook node's `parameters.path`, not a workflow id.
+     */
+    triggerWebhook(path: string, payload?: unknown, init?: {
+        method?: string;
+    }): Promise<unknown>;
+}
+/** Normalize GET /v1/credentials: the API returns `{data: []}`. */
+export declare function unwrapCredentialList(payload: any): CredentialMetadata[];
+/**
+ * Normalize GET /v1/executions responses: the engine returns `{data: []}`
+ * (envelope, forward-compat with the old n8n proxy); older mocks return a
+ * bare array. Accepts both so callers always get an array.
+ */
+export declare function unwrapExecutions(payload: any): any[];
+/**
+ * Fire a public inbound webhook: `ANY /webhook/:path` (no auth) triggers the
+ * ACTIVE workflow whose webhook node declares that `path`.
+ *
+ * The gateway proxies `/webhook/*` to the workflow service, so `webhookBaseUrl`
+ * is normally the gateway URL. Use `client.workflow.triggerWebhook()` for the
+ * gateway-bound convenience form. `path` is the webhook node's
+ * `parameters.path` (e.g. `synapseone-event`), not a workflow id.
+ */
+export declare function triggerWebhook(webhookBaseUrl: string, path: string, payload?: unknown, init?: {
+    method?: string;
+    timeoutMs?: number;
+}): Promise<any>;

package/dist/workflow.js

@@ -0,0 +1,185 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * Workflow client: templates, workflow CRUD/lifecycle, executions, test runs
+ * and public inbound webhooks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowService = void 0;
+exports.unwrapCredentialList = unwrapCredentialList;
+exports.unwrapExecutions = unwrapExecutions;
+exports.triggerWebhook = triggerWebhook;
+class WorkflowService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    // ---- templates ----
+    listTemplates() { return this.http.req('/v1/templates'); }
+    getTemplate(name) { return this.http.req(`/v1/templates/${encodeURIComponent(name)}`); }
+    // ---- workflows ----
+    listWorkflows() { return this.http.req('/v1/workflows'); }
+    getWorkflow(id) { return this.http.req(`/v1/workflows/${encodeURIComponent(id)}`); }
+    createWorkflowFromTemplate(template, name) {
+        return this.http.req('/v1/workflows', { method: 'POST', body: JSON.stringify({ template, name }) });
+    }
+    createWorkflow(name, definition, settings) {
+        return this.http.req('/v1/workflows', { method: 'POST', body: JSON.stringify({ name, definition, ...(settings ? { settings } : {}) }) });
+    }
+    updateWorkflow(id, patch) {
+        return this.http.req(`/v1/workflows/${encodeURIComponent(id)}`, { method: 'PUT', body: JSON.stringify(patch) });
+    }
+    deleteWorkflow(id) {
+        return this.http.req(`/v1/workflows/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    activateWorkflow(id) { return this.http.req(`/v1/workflows/${encodeURIComponent(id)}/activate`, { method: 'POST' }); }
+    deactivateWorkflow(id) { return this.http.req(`/v1/workflows/${encodeURIComponent(id)}/deactivate`, { method: 'POST' }); }
+    executeWorkflow(id, payload = {}) {
+        return this.http.req(`/v1/workflows/${encodeURIComponent(id)}/execute`, { method: 'POST', body: JSON.stringify(payload) });
+    }
+    // ---- executions ----
+    getExecution(id, includeData = false) {
+        const qs = includeData ? '?includeData=true' : '';
+        return this.http.req(`/v1/executions/${encodeURIComponent(id)}${qs}`);
+    }
+    listExecutions(query = '') {
+        let q = '';
+        if (typeof query === 'string') {
+            q = query ? (query.startsWith('?') ? query : `?${query}`) : '';
+        }
+        else if (query && typeof query === 'object') {
+            // Allowlist mirrors GET /v1/executions (limit/offset/workflowId/status/triggeredBy/includeData).
+            const allowed = ['limit', 'offset', 'workflowId', 'status', 'triggeredBy', 'includeData'];
+            const params = new URLSearchParams();
+            for (const k of allowed) {
+                const v = query[k];
+                if (v !== undefined && v !== null && String(v) !== '')
+                    params.set(k, String(v));
+            }
+            const s = params.toString();
+            q = s ? `?${s}` : '';
+        }
+        return this.http.req(`/v1/executions${q}`).then(unwrapExecutions);
+    }
+    testRun(definition, input = {}, workflowId) {
+        return this.http.req('/v1/workflows/test-run', { method: 'POST', body: JSON.stringify({ definition, input, ...(workflowId ? { workflowId } : {}) }) });
+    }
+    // ---- credentials (account-scoped secrets, encrypted at rest) ----
+    // Secrets are write-only: create/rotate accept `secret` once, every read
+    // returns metadata only. Kinds: bearer | api-key | basic | hmac.
+    createCredential(inputOrAccountId, opts) {
+        const body = typeof inputOrAccountId === 'string'
+            ? {
+                accountId: inputOrAccountId,
+                name: opts?.name,
+                kind: opts?.kind || opts?.type || 'bearer',
+                secret: opts?.secret,
+            }
+            : {
+                accountId: inputOrAccountId.accountId,
+                name: inputOrAccountId.name,
+                kind: inputOrAccountId.kind || inputOrAccountId.type || 'bearer',
+                secret: inputOrAccountId.secret,
+            };
+        return this.http.req('/v1/credentials', {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    listCredentials(accountId) {
+        const qs = accountId ? `?accountId=${encodeURIComponent(accountId)}` : '';
+        return this.http.req(`/v1/credentials${qs}`).then(unwrapCredentialList);
+    }
+    getCredential(id) {
+        return this.http.req(`/v1/credentials/${encodeURIComponent(id)}`);
+    }
+    rotateCredential(id, secret) {
+        return this.http.req(`/v1/credentials/${encodeURIComponent(id)}/rotate`, {
+            method: 'POST',
+            body: JSON.stringify({ secret }),
+        });
+    }
+    deleteCredential(id) {
+        return this.http.req(`/v1/credentials/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    // ---- public inbound webhooks ----
+    /**
+     * Fire a public inbound webhook through the gateway: `ANY /webhook/:path`.
+     * No auth is required; per-workflow auth/rate-limit/idempotency still apply.
+     * `path` is the webhook node's `parameters.path`, not a workflow id.
+     */
+    triggerWebhook(path, payload, init = {}) {
+        const clean = String(path || '').replace(/^\/+|\/+$/g, '').split('?')[0];
+        if (!clean)
+            throw new Error('synapseone webhook: path required');
+        const method = (init.method || (payload === undefined ? 'GET' : 'POST')).toUpperCase();
+        return this.http.call(method, `/webhook/${clean}`, payload);
+    }
+}
+exports.WorkflowService = WorkflowService;
+/** Normalize GET /v1/credentials: the API returns `{data: []}`. */
+function unwrapCredentialList(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    if (payload && Array.isArray(payload.data))
+        return payload.data;
+    return payload == null ? [] : payload;
+}
+/**
+ * Normalize GET /v1/executions responses: the engine returns `{data: []}`
+ * (envelope, forward-compat with the old n8n proxy); older mocks return a
+ * bare array. Accepts both so callers always get an array.
+ */
+function unwrapExecutions(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    if (payload && Array.isArray(payload.data))
+        return payload.data;
+    return payload == null ? [] : payload;
+}
+/**
+ * Fire a public inbound webhook: `ANY /webhook/:path` (no auth) triggers the
+ * ACTIVE workflow whose webhook node declares that `path`.
+ *
+ * The gateway proxies `/webhook/*` to the workflow service, so `webhookBaseUrl`
+ * is normally the gateway URL. Use `client.workflow.triggerWebhook()` for the
+ * gateway-bound convenience form. `path` is the webhook node's
+ * `parameters.path` (e.g. `synapseone-event`), not a workflow id.
+ */
+async function triggerWebhook(webhookBaseUrl, path, payload, init) {
+    const base = webhookBaseUrl.replace(/\/$/, '');
+    const clean = String(path || '').replace(/^\/+|\/+$/g, '').split('?')[0];
+    if (!clean)
+        throw new Error('synapseone webhook: path required');
+    const method = (init?.method || (payload === undefined ? 'GET' : 'POST')).toUpperCase();
+    const url = `${base}/webhook/${clean}`;
+    const ctl = new AbortController();
+    const to = setTimeout(() => ctl.abort(), init?.timeoutMs ?? 15000);
+    let r;
+    try {
+        r = await fetch(url, {
+            method,
+            signal: ctl.signal,
+            headers: { 'Content-Type': 'application/json' },
+            body: payload === undefined ? undefined : JSON.stringify(payload),
+        });
+    }
+    catch (e) {
+        throw new Error(`synapseone network /webhook/${clean}: ${e?.message || e}`);
+    }
+    finally {
+        clearTimeout(to);
+    }
+    const text = await r.text();
+    let data = null;
+    try {
+        data = text ? JSON.parse(text) : null;
+    }
+    catch {
+        data = text;
+    }
+    if (!r.ok)
+        throw new Error(`synapseone ${r.status} /webhook/${clean}: ${typeof data === 'string' ? data : JSON.stringify(data)}`);
+    return data;
+}

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "@synapseone/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.0-dev.43",
+  "license": "Apache-2.0",
+  "description": "synapseone SDK for JavaScript/TypeScript",
+  "homepage": "https://synapseone.space",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vku-open-source-2026/SynapseOne.git",
+    "directory": "sdks/sdk-js"
+  },
+  "bugs": {
+    "url": "https://github.com/vku-open-source-2026/SynapseOne/issues"
+  },
+  "keywords": [
+    "synapseone",
+    "sdk",
+    "paas",
+    "iam",
+    "workflow",
+    "ngsi-ld",
+    "document-db",
+    "redis",
+    "queue"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./iam": {
+      "types": "./dist/iam.d.ts",
+      "require": "./dist/iam.js",
+      "default": "./dist/iam.js"
+    },
+    "./workflow": {
+      "types": "./dist/workflow.d.ts",
+      "require": "./dist/workflow.js",
+      "default": "./dist/workflow.js"
+    },
+    "./lds": {
+      "types": "./dist/lds.d.ts",
+      "require": "./dist/lds.js",
+      "default": "./dist/lds.js"
+    },
+    "./base": {
+      "types": "./dist/base.d.ts",
+      "require": "./dist/base.js",
+      "default": "./dist/base.js"
+    },
+    "./faststore": {
+      "types": "./dist/faststore.d.ts",
+      "require": "./dist/faststore.js",
+      "default": "./dist/faststore.js"
+    },
+    "./queue": {
+      "types": "./dist/queue.d.ts",
+      "require": "./dist/queue.js",
+      "default": "./dist/queue.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test dist/client.test.js dist/services.test.js",
+    "lint": "echo lint-ok"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/node": "^20.14.0"
+  }
+}