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

package/dist/lds.d.ts

@@ -0,0 +1,82 @@
+import { HttpClient } from './_http';
+/** LDS attribute/datasource visibility (`internal` is settable but not listable via `?visibility`). */
+export type LdsVisibility = 'public' | 'restricted' | 'internal';
+/** NGSI-LD attribute types accepted by PUT /v1/lds/datasources/:id/attributes. */
+export type LdsAttributeType = 'Property' | 'Relationship' | 'GeoProperty';
+/** Body of POST /v1/lds/datasources; PATCH accepts a partial of this. */
+export interface LdsDatasourceInput {
+    name: string;
+    slug?: string;
+    entityType: string;
+    license: string;
+    licenseUrl?: string;
+    contexts?: string[];
+    defaultVisibility?: LdsVisibility;
+    description?: string;
+    orgId?: string;
+    accountId?: string;
+}
+/** One attribute row for PUT /v1/lds/datasources/:id/attributes. */
+export interface LdsAttributeInput {
+    name: string;
+    ngsiLdType?: LdsAttributeType;
+    visibility?: LdsVisibility;
+    description?: string;
+    sourceField?: string;
+}
+/** Query for GET /v1/lds/datasources/:id/entities (limit 1..500, default 100). */
+export interface LdsEntitiesQuery {
+    limit?: number;
+    offset?: number;
+    visibility?: 'public' | 'restricted';
+}
+/** Result of POST /v1/lds/datasources/:id/records (quarantine reasons are per field). */
+export interface LdsIngestResult {
+    ingested: number;
+    created: number;
+    updated: number;
+    quarantined: {
+        field: string;
+        reason: string;
+    }[];
+    entities: {
+        id: string;
+        entityId: string;
+        sourceRecordId?: string;
+    }[];
+}
+export declare class LdsService {
+    private readonly http;
+    constructor(http: HttpClient);
+    licenses(): Promise<any[]>;
+    datasources(query?: {
+        orgId?: string;
+        accountId?: string;
+    }): Promise<any[]>;
+    createDatasource(input: LdsDatasourceInput): Promise<unknown>;
+    datasource(id: string): Promise<unknown>;
+    updateDatasource(id: string, patch: Partial<LdsDatasourceInput>): Promise<unknown>;
+    deleteDatasource(id: string): Promise<{
+        ok: boolean;
+    }>;
+    attributes(id: string): Promise<any[]>;
+    setAttributes(id: string, attributes: LdsAttributeInput[]): Promise<any[]>;
+    /**
+     * Ingest into a datasource. `records` accepts a single record object, an
+     * array (wrapped as `{records}`), or a pre-wrapped `{records}`/`{record}`
+     * body — all three shapes the endpoint accepts.
+     */
+    ingest(id: string, records: Record<string, unknown> | Record<string, unknown>[]): Promise<LdsIngestResult>;
+    /** List NGSI-LD entities; limit 1..500 (default 100), visibility public|restricted only. */
+    entities(id: string, query?: LdsEntitiesQuery): Promise<any[]>;
+    entity(id: string, entityId: string): Promise<unknown>;
+    stats(id: string): Promise<{
+        records: number;
+        attributes: {
+            public: number;
+            restricted: number;
+            internal: number;
+        };
+        lastIngestAt: string | null;
+    }>;
+}

package/dist/lds.js

@@ -0,0 +1,77 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * LDS (linked-data service) client: datasources, attributes, records,
+ * NGSI-LD entities, stats and licenses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LdsService = void 0;
+class LdsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    licenses() { return this.http.req('/v1/lds/licenses'); }
+    datasources(query = {}) {
+        const params = new URLSearchParams();
+        if (query.orgId)
+            params.set('orgId', query.orgId);
+        if (query.accountId)
+            params.set('accountId', query.accountId);
+        const s = params.toString();
+        return this.http.req(`/v1/lds/datasources${s ? `?${s}` : ''}`);
+    }
+    createDatasource(input) {
+        return this.http.req('/v1/lds/datasources', { method: 'POST', body: JSON.stringify(input) });
+    }
+    datasource(id) { return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}`); }
+    updateDatasource(id, patch) {
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}`, { method: 'PATCH', body: JSON.stringify(patch) });
+    }
+    deleteDatasource(id) {
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    attributes(id) {
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}/attributes`);
+    }
+    setAttributes(id, attributes) {
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}/attributes`, {
+            method: 'PUT', body: JSON.stringify({ attributes }),
+        });
+    }
+    /**
+     * Ingest into a datasource. `records` accepts a single record object, an
+     * array (wrapped as `{records}`), or a pre-wrapped `{records}`/`{record}`
+     * body — all three shapes the endpoint accepts.
+     */
+    ingest(id, records) {
+        const body = Array.isArray(records)
+            ? { records }
+            : records && typeof records === 'object' && ('records' in records || 'record' in records)
+                ? records
+                : { record: records };
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}/records`, {
+            method: 'POST', body: JSON.stringify(body),
+        });
+    }
+    /** List NGSI-LD entities; limit 1..500 (default 100), visibility public|restricted only. */
+    entities(id, query = {}) {
+        const allowed = ['limit', 'offset', 'visibility'];
+        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();
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}/entities${s ? `?${s}` : ''}`);
+    }
+    entity(id, entityId) {
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}/entities/${encodeURIComponent(entityId)}`);
+    }
+    stats(id) {
+        return this.http.req(`/v1/lds/datasources/${encodeURIComponent(id)}/stats`);
+    }
+}
+exports.LdsService = LdsService;

package/dist/queue.d.ts

@@ -0,0 +1,72 @@
+import { HttpClient } from './_http';
+export declare class QueueService {
+    private readonly http;
+    constructor(http: HttpClient);
+    private q;
+    listQueues(): Promise<any[]>;
+    createQueue(queue: string, opts?: {
+        maxAttempts?: number;
+        visibilityTimeoutSeconds?: number;
+    }): Promise<unknown>;
+    getQueue(queue: string): Promise<unknown>;
+    deleteQueue(queue: string): Promise<unknown>;
+    purgeQueue(queue: string): Promise<unknown>;
+    queueStats(queue: string): Promise<unknown>;
+    publish(queue: string, payload: unknown, opts?: {
+        delaySeconds?: number;
+        maxAttempts?: number;
+        headers?: Record<string, unknown>;
+        id?: string;
+        dedupeKey?: string;
+    }): Promise<unknown>;
+    /** Publish 1..100 messages; each entry takes the same fields as `publish`. */
+    publishBatch(queue: string, messages: Array<Record<string, unknown>>): Promise<{
+        queue: string;
+        results: any[];
+        ok: boolean;
+    }>;
+    consume(queue: string, opts?: {
+        maxMessages?: number;
+        visibilityTimeoutSeconds?: number;
+        consumer?: string;
+    }): Promise<{
+        queue: string;
+        count: number;
+        visibilityTimeoutSeconds: number;
+        messages: any[];
+    }>;
+    ack(queue: string, receipt: string): Promise<unknown>;
+    ackMany(queue: string, receipts: string[]): Promise<{
+        queue: string;
+        results: any[];
+        ok: boolean;
+    }>;
+    nack(queue: string, receipt: string, opts?: {
+        requeue?: boolean;
+        delaySeconds?: number;
+        error?: string;
+    }): Promise<unknown>;
+    heartbeat(queue: string, receipt: string, opts?: {
+        visibilityTimeoutSeconds?: number;
+    }): Promise<unknown>;
+    peek(queue: string, opts?: {
+        limit?: number;
+        ready?: boolean;
+    }): Promise<{
+        queue: string;
+        count: number;
+        messages: any[];
+    }>;
+    deadLetters(queue: string, opts?: {
+        limit?: number;
+    }): Promise<{
+        queue: string;
+        count: number;
+        messages: any[];
+    }>;
+    replayDead(queue: string, messageId: string, opts?: {
+        delaySeconds?: number;
+        resetAttempts?: boolean;
+    }): Promise<unknown>;
+    deleteDead(queue: string, messageId: string): Promise<unknown>;
+}

package/dist/queue.js

@@ -0,0 +1,129 @@
+"use strict";
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * SynapseQueue client: queues, publish (delay + dedupe), at-least-once
+ * consumption with visibility-timeout leases, ack/nack/heartbeat, retry,
+ * dead letters and replay.
+ *
+ * Delivery model: `consume()` leases messages and returns a `receipt` per
+ * message. `ack` when processing succeeds, `nack` to requeue/dead-letter and
+ * `heartbeat` to extend long-running leases. Expired leases are redelivered,
+ * so consumers must be idempotent.
+ *
+ * Every operation is scoped to the caller's tenant (org / account / user).
+ * Platform callers set `tenant` on the client (x-synapseone-tenant).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueService = void 0;
+const P = '/v1/queue/queues';
+class QueueService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    q(queue) {
+        return encodeURIComponent(queue);
+    }
+    // ---- queues ----
+    listQueues() { return this.http.req(P); }
+    createQueue(queue, opts = {}) {
+        return this.http.req(`${P}/${this.q(queue)}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                ...(opts.maxAttempts !== undefined ? { maxAttempts: opts.maxAttempts } : {}),
+                ...(opts.visibilityTimeoutSeconds !== undefined ? { visibilityTimeoutSeconds: opts.visibilityTimeoutSeconds } : {}),
+            }),
+        });
+    }
+    getQueue(queue) { return this.http.req(`${P}/${this.q(queue)}`); }
+    deleteQueue(queue) { return this.http.req(`${P}/${this.q(queue)}`, { method: 'DELETE' }); }
+    purgeQueue(queue) { return this.http.req(`${P}/${this.q(queue)}/purge`, { method: 'POST' }); }
+    queueStats(queue) { return this.http.req(`${P}/${this.q(queue)}/stats`); }
+    // ---- publish ----
+    publish(queue, payload, opts = {}) {
+        return this.http.req(`${P}/${this.q(queue)}/messages`, {
+            method: 'POST',
+            body: JSON.stringify({
+                payload,
+                ...(opts.delaySeconds !== undefined ? { delaySeconds: opts.delaySeconds } : {}),
+                ...(opts.maxAttempts !== undefined ? { maxAttempts: opts.maxAttempts } : {}),
+                ...(opts.headers !== undefined ? { headers: opts.headers } : {}),
+                ...(opts.id !== undefined ? { id: opts.id } : {}),
+                ...(opts.dedupeKey !== undefined ? { dedupeKey: opts.dedupeKey } : {}),
+            }),
+        });
+    }
+    /** Publish 1..100 messages; each entry takes the same fields as `publish`. */
+    publishBatch(queue, messages) {
+        return this.http.req(`${P}/${this.q(queue)}/messages:batch`, {
+            method: 'POST', body: JSON.stringify({ messages }),
+        });
+    }
+    // ---- consume / ack / nack / heartbeat ----
+    consume(queue, opts = {}) {
+        return this.http.req(`${P}/${this.q(queue)}/consume`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ...(opts.maxMessages !== undefined ? { maxMessages: opts.maxMessages } : {}),
+                ...(opts.visibilityTimeoutSeconds !== undefined ? { visibilityTimeoutSeconds: opts.visibilityTimeoutSeconds } : {}),
+                ...(opts.consumer !== undefined ? { consumer: opts.consumer } : {}),
+            }),
+        });
+    }
+    ack(queue, receipt) {
+        return this.http.req(`${P}/${this.q(queue)}/ack`, { method: 'POST', body: JSON.stringify({ receipt }) });
+    }
+    ackMany(queue, receipts) {
+        return this.http.req(`${P}/${this.q(queue)}/ack`, {
+            method: 'POST', body: JSON.stringify({ receipts }),
+        });
+    }
+    nack(queue, receipt, opts = {}) {
+        return this.http.req(`${P}/${this.q(queue)}/nack`, {
+            method: 'POST',
+            body: JSON.stringify({
+                receipt,
+                requeue: opts.requeue ?? true,
+                ...(opts.delaySeconds !== undefined ? { delaySeconds: opts.delaySeconds } : {}),
+                ...(opts.error !== undefined ? { error: opts.error } : {}),
+            }),
+        });
+    }
+    heartbeat(queue, receipt, opts = {}) {
+        return this.http.req(`${P}/${this.q(queue)}/heartbeat`, {
+            method: 'POST',
+            body: JSON.stringify({
+                receipt,
+                ...(opts.visibilityTimeoutSeconds !== undefined ? { visibilityTimeoutSeconds: opts.visibilityTimeoutSeconds } : {}),
+            }),
+        });
+    }
+    // ---- inspection / dead letters ----
+    peek(queue, opts = {}) {
+        const p = new URLSearchParams();
+        if (opts.limit !== undefined)
+            p.set('limit', String(opts.limit));
+        if (opts.ready)
+            p.set('ready', 'true');
+        const s = p.toString();
+        return this.http.req(`${P}/${this.q(queue)}/messages${s ? `?${s}` : ''}`);
+    }
+    deadLetters(queue, opts = {}) {
+        const s = opts.limit !== undefined ? `?limit=${opts.limit}` : '';
+        return this.http.req(`${P}/${this.q(queue)}/dead${s}`);
+    }
+    replayDead(queue, messageId, opts = {}) {
+        return this.http.req(`${P}/${this.q(queue)}/dead/${encodeURIComponent(messageId)}/replay`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ...(opts.delaySeconds !== undefined ? { delaySeconds: opts.delaySeconds } : {}),
+                ...(opts.resetAttempts ? { resetAttempts: true } : {}),
+            }),
+        });
+    }
+    deleteDead(queue, messageId) {
+        return this.http.req(`${P}/${this.q(queue)}/dead/${encodeURIComponent(messageId)}`, { method: 'DELETE' });
+    }
+}
+exports.QueueService = QueueService;

package/dist/services.test.d.ts

@@ -0,0 +1 @@
+export {};