@synapseone/sdk 0.7.1-dev.57 → 0.7.1-dev.59

package/dist/index.d.ts

@@ -10,6 +10,7 @@ import { InferenceService } from './inference';
 import { AiService } from './ai';
 import { HealthService } from './health';
 import { StorageService } from './storage';
+import { OcsService } from './ocs';
 import { NotificationsService } from './notifications';
 export * from './_http';
 export * from './iam';
@@ -23,6 +24,7 @@ export * from './stream';
 export * from './inference';
 export * from './health';
 export * from './storage';
+export * from './ocs';
 export * from './notifications';
 /** Legacy flat LDS signatures (the namespaced service drops the `lds` prefix). */
 export interface LdsLegacyMethods {
@@ -56,6 +58,8 @@ export declare class SynapseOneClient {
     readonly stream: StreamService;
     readonly inference: InferenceService;
     readonly storage: StorageService;
+    /** SynapseOCS bucket/object API; `storage` remains the default-bucket alias. */
+    readonly ocs: OcsService;
     readonly notifications: NotificationsService;
     readonly health: HealthService;
     readonly readiness: HealthService;

package/dist/index.js

@@ -50,6 +50,7 @@ const inference_1 = require("./inference");
 const ai_1 = require("./ai");
 const health_1 = require("./health");
 const storage_1 = require("./storage");
+const ocs_1 = require("./ocs");
 const notifications_1 = require("./notifications");
 __exportStar(require("./_http"), exports);
 __exportStar(require("./iam"), exports);
@@ -63,6 +64,7 @@ __exportStar(require("./stream"), exports);
 __exportStar(require("./inference"), exports);
 __exportStar(require("./health"), exports);
 __exportStar(require("./storage"), exports);
+__exportStar(require("./ocs"), exports);
 __exportStar(require("./notifications"), exports);
 class SynapseOneClient {
     http;
@@ -76,6 +78,8 @@ class SynapseOneClient {
     stream;
     inference;
     storage;
+    /** SynapseOCS bucket/object API; `storage` remains the default-bucket alias. */
+    ocs;
     notifications;
     health;
     readiness;
@@ -91,6 +95,7 @@ class SynapseOneClient {
         this.stream = new stream_1.StreamService(this.http);
         this.inference = new inference_1.InferenceService(this.http);
         this.storage = new storage_1.StorageService(this.http);
+        this.ocs = new ocs_1.OcsService(this.http);
         this.notifications = new notifications_1.NotificationsService(this.http);
         this.health = new health_1.HealthService(this.http);
         // Alias: `client.readiness.ready()` reads naturally; same instance.

package/dist/ocs.d.ts

@@ -0,0 +1,119 @@
+import { HttpClient, RequestOptions } from './_http';
+export interface OcsBucket {
+    name: string;
+    createdAt: string;
+    updatedAt?: string;
+    owner?: string;
+    quotaBytes?: number;
+    objects?: number;
+    bytes?: number;
+}
+export interface OcsObject {
+    key: string;
+    bucket: string;
+    size: number;
+    contentType: string;
+    etag: string;
+    checksumSha256?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface OcsList {
+    bucket: string;
+    prefix: string;
+    delimiter?: string;
+    objects: OcsObject[];
+    commonPrefixes: string[];
+    nextCursor: string | null;
+}
+export interface PutOcsOptions extends RequestOptions {
+    contentType?: string;
+    checksumSha256?: string;
+}
+export interface GetOcsOptions extends RequestOptions {
+    range?: string;
+    ifNoneMatch?: string;
+    ifMatch?: string;
+}
+export declare class OcsService {
+    private readonly http;
+    constructor(http: HttpClient);
+    createBucket(name: string, opts?: {
+        quotaBytes?: number;
+    }): Promise<{
+        bucket: OcsBucket;
+    }>;
+    listBuckets(opts?: {
+        withStats?: boolean;
+    }): Promise<{
+        buckets: OcsBucket[];
+        total: number;
+    }>;
+    getBucket(name: string): Promise<{
+        bucket: OcsBucket;
+    }>;
+    headBucket(name: string, opts?: RequestOptions): Promise<Record<string, string> | null>;
+    bucketStats(name: string): Promise<{
+        bucket: string;
+        objects: number;
+        bytes: number;
+        quotaBytes: number;
+    }>;
+    deleteBucket(name: string, opts?: {
+        force?: boolean;
+    }): Promise<{
+        ok: boolean;
+        bucket: string;
+        deletedObjects: number;
+    }>;
+    putObject(bucket: string, key: string, body: Uint8Array | ArrayBuffer | string, opts?: PutOcsOptions): Promise<OcsObject>;
+    getObject(bucket: string, key: string, opts?: GetOcsOptions): Promise<Uint8Array>;
+    headObject(bucket: string, key: string, opts?: RequestOptions): Promise<OcsObject | null>;
+    deleteObject(bucket: string, key: string): Promise<{
+        ok: boolean;
+        bucket: string;
+        key: string;
+    }>;
+    listObjects(bucket: string, opts?: {
+        prefix?: string;
+        delimiter?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<OcsList>;
+    copyObject(bucket: string, input: {
+        sourceKey: string;
+        destinationKey: string;
+        sourceBucket?: string;
+        contentType?: string;
+    }): Promise<{
+        object: OcsObject;
+    }>;
+    presign(bucket: string, key: string, opts?: {
+        method?: 'GET' | 'PUT' | 'DELETE' | 'HEAD';
+        expiresIn?: number;
+    }): Promise<{
+        url: string;
+        bucket: string;
+        key: string;
+        method: string;
+        expiresIn: number;
+    }>;
+    createMultipart(bucket: string, key: string, contentType?: string): Promise<{
+        uploadId: string;
+        bucket: string;
+        key: string;
+        contentType: string;
+    }>;
+    uploadPart(bucket: string, uploadId: string, key: string, partNumber: number, body: Uint8Array | string): Promise<{
+        partNumber: number;
+        etag: string;
+        size: number;
+    }>;
+    completeMultipart(bucket: string, uploadId: string, key: string, parts: Array<{
+        partNumber: number;
+        etag: string;
+    }>): Promise<{
+        object: OcsObject;
+    }>;
+    abortMultipart(bucket: string, uploadId: string, key: string): Promise<unknown>;
+}

package/dist/ocs.js

@@ -0,0 +1,130 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * SynapseOCS client: buckets, objects, copy, range/conditional reads,
+ * delimited listing, presigned URLs and multipart uploads.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcsService = void 0;
+const P = '/v1/ocs';
+class OcsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    createBucket(name, opts = {}) {
+        return this.http.req(`${P}/buckets`, {
+            method: 'POST',
+            body: JSON.stringify({ name, ...(opts.quotaBytes ? { quotaBytes: opts.quotaBytes } : {}) }),
+        });
+    }
+    listBuckets(opts = {}) {
+        return this.http.req(`${P}/buckets${opts.withStats ? '?withStats=1' : ''}`);
+    }
+    getBucket(name) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(name)}`);
+    }
+    async headBucket(name, opts = {}) {
+        try {
+            return await this.http.head(`${P}/buckets/${encodeURIComponent(name)}`, opts);
+        }
+        catch (error) {
+            if (error?.status === 404)
+                return null;
+            throw error;
+        }
+    }
+    bucketStats(name) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(name)}/stats`);
+    }
+    deleteBucket(name, opts = {}) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(name)}${opts.force ? '?force=true' : ''}`, { method: 'DELETE' });
+    }
+    async putObject(bucket, key, body, opts = {}) {
+        const bytes = typeof body === 'string' ? new TextEncoder().encode(body) : body instanceof Uint8Array ? body : new Uint8Array(body);
+        const result = await this.http.upload(`${P}/buckets/${encodeURIComponent(bucket)}/objects/${encodeKey(key)}`, bytes, {
+            ...opts,
+            contentType: opts.contentType || 'application/octet-stream',
+            headers: { ...(opts.checksumSha256 ? { 'x-object-checksum-sha256': opts.checksumSha256 } : {}), ...(opts.headers || {}) },
+        });
+        return result.object;
+    }
+    getObject(bucket, key, opts = {}) {
+        const headers = { ...(opts.headers || {}) };
+        if (opts.range)
+            headers.Range = opts.range;
+        if (opts.ifNoneMatch)
+            headers['If-None-Match'] = opts.ifNoneMatch;
+        if (opts.ifMatch)
+            headers['If-Match'] = opts.ifMatch;
+        return this.http.reqBinary(`${P}/buckets/${encodeURIComponent(bucket)}/objects/${encodeKey(key)}`, undefined, { ...opts, headers });
+    }
+    async headObject(bucket, key, opts = {}) {
+        try {
+            const headers = await this.http.head(`${P}/buckets/${encodeURIComponent(bucket)}/objects/${encodeKey(key)}`, opts);
+            return {
+                key: headers['x-object-key'] || key,
+                bucket: headers['x-ocs-bucket'] || bucket,
+                size: Number(headers['content-length'] || 0),
+                contentType: headers['content-type'] || 'application/octet-stream',
+                etag: (headers.etag || '').replace(/"/g, ''),
+                checksumSha256: headers['x-object-checksum-sha256'],
+                createdAt: headers['x-object-created-at'] || '',
+                updatedAt: headers['x-object-updated-at'] || '',
+            };
+        }
+        catch (error) {
+            if (error?.status === 404)
+                return null;
+            throw error;
+        }
+    }
+    deleteObject(bucket, key) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/objects/${encodeKey(key)}`, { method: 'DELETE' });
+    }
+    listObjects(bucket, opts = {}) {
+        const query = new URLSearchParams();
+        if (opts.prefix)
+            query.set('prefix', opts.prefix);
+        if (opts.delimiter)
+            query.set('delimiter', opts.delimiter);
+        if (opts.limit)
+            query.set('limit', String(opts.limit));
+        if (opts.cursor)
+            query.set('cursor', opts.cursor);
+        const suffix = query.toString();
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/objects${suffix ? `?${suffix}` : ''}`);
+    }
+    copyObject(bucket, input) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/objects/copy`, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    presign(bucket, key, opts = {}) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/presign`, { method: 'POST', body: JSON.stringify({ key, method: opts.method || 'GET', expiresIn: opts.expiresIn ?? 900 }) });
+    }
+    createMultipart(bucket, key, contentType = 'application/octet-stream') {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/uploads`, { method: 'POST', body: JSON.stringify({ key, contentType }) });
+    }
+    uploadPart(bucket, uploadId, key, partNumber, body) {
+        const bytes = typeof body === 'string' ? new TextEncoder().encode(body) : body;
+        return this.http.upload(`${P}/buckets/${encodeURIComponent(bucket)}/uploads/${encodeURIComponent(uploadId)}/parts/${partNumber}?key=${encodeURIComponent(key)}`, bytes, { method: 'PUT', contentType: 'application/octet-stream' });
+    }
+    completeMultipart(bucket, uploadId, key, parts) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/uploads/${encodeURIComponent(uploadId)}/complete`, { method: 'POST', body: JSON.stringify({ key, parts }) });
+    }
+    abortMultipart(bucket, uploadId, key) {
+        return this.http.req(`${P}/buckets/${encodeURIComponent(bucket)}/uploads/${encodeURIComponent(uploadId)}?key=${encodeURIComponent(key)}`, { method: 'DELETE' });
+    }
+}
+exports.OcsService = OcsService;
+function encodeKey(key) {
+    return String(key || '')
+        .split('/')
+        .map((segment) => encodeURIComponent(segment))
+        .join('/');
+}

package/dist/ocs.test.d.ts

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

package/dist/ocs.test.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/* SynapseOCS JS SDK contract tests: buckets, objects, copy, list, multipart. */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_http_1 = __importDefault(require("node:http"));
+const index_1 = require("./index");
+let server;
+let base = '';
+const calls = [];
+(0, node_test_1.before)(() => new Promise((resolve) => {
+    server = node_http_1.default.createServer((req, res) => {
+        const url = new URL(req.url || '/', 'http://x');
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => {
+            const body = Buffer.concat(chunks).toString('utf8');
+            calls.push({ method: req.method || 'GET', path: url.pathname + url.search, body });
+            res.setHeader('content-type', 'application/json');
+            if (url.pathname === '/v1/ocs/buckets' && req.method === 'GET') {
+                res.end(JSON.stringify({ buckets: [{ name: 'media', createdAt: 't' }], total: 1 }));
+                return;
+            }
+            if (url.pathname === '/v1/ocs/buckets' && req.method === 'POST') {
+                res.statusCode = 201;
+                res.end(JSON.stringify({ bucket: { name: 'media', createdAt: 't' } }));
+                return;
+            }
+            if (url.pathname.endsWith('/stats')) {
+                res.end(JSON.stringify({ bucket: 'media', objects: 1, bytes: 5, quotaBytes: 100 }));
+                return;
+            }
+            if (url.pathname.endsWith('/objects') && req.method === 'GET') {
+                res.end(JSON.stringify({ bucket: 'media', prefix: '', objects: [{ key: 'a.txt', bucket: 'media', size: 5, contentType: 'text/plain', etag: 'e', createdAt: 't', updatedAt: 't' }], commonPrefixes: [], nextCursor: null }));
+                return;
+            }
+            if (url.pathname.endsWith('/copy')) {
+                res.statusCode = 201;
+                res.end(JSON.stringify({ object: { key: 'b.txt', bucket: 'media', size: 5, contentType: 'text/plain', etag: 'e', createdAt: 't', updatedAt: 't' } }));
+                return;
+            }
+            if (url.pathname.endsWith('/presign')) {
+                res.end(JSON.stringify({ url: 'https://ocs.example/x', bucket: 'media', key: 'a.txt', method: 'GET', expiresIn: 60 }));
+                return;
+            }
+            if (url.pathname.endsWith('/uploads')) {
+                res.statusCode = 201;
+                res.end(JSON.stringify({ uploadId: 'u1', bucket: 'media', key: 'a.txt', contentType: 'text/plain' }));
+                return;
+            }
+            if (url.pathname.includes('/parts/')) {
+                res.end(JSON.stringify({ partNumber: 1, etag: 'p1', size: 3 }));
+                return;
+            }
+            if (url.pathname.endsWith('/complete')) {
+                res.statusCode = 201;
+                res.end(JSON.stringify({ object: { key: 'a.txt', bucket: 'media', size: 3, contentType: 'text/plain', etag: 'e', createdAt: 't', updatedAt: 't' } }));
+                return;
+            }
+            if (req.method === 'PUT') {
+                res.statusCode = 201;
+                res.end(JSON.stringify({ object: { key: 'a.txt', bucket: 'media', size: 5, contentType: 'text/plain', etag: 'e', createdAt: 't', updatedAt: 't' } }));
+                return;
+            }
+            if (req.method === 'HEAD') {
+                res.setHeader('content-length', '5');
+                res.setHeader('content-type', 'text/plain');
+                res.setHeader('etag', '"e"');
+                res.setHeader('x-object-key', 'a.txt');
+                res.setHeader('x-ocs-bucket', 'media');
+                res.end();
+                return;
+            }
+            if (req.method === 'DELETE') {
+                res.end(JSON.stringify({ ok: true, bucket: 'media', key: 'a.txt' }));
+                return;
+            }
+            if (req.method === 'GET') {
+                res.setHeader('content-type', 'text/plain');
+                res.end('hello');
+                return;
+            }
+            res.statusCode = 404;
+            res.end('{}');
+        });
+    }).listen(0, '127.0.0.1', () => {
+        const address = server.address();
+        base = `http://127.0.0.1:${typeof address === 'object' && address ? address.port : 0}`;
+        resolve();
+    });
+}));
+(0, node_test_1.after)(() => new Promise((resolve) => server.close(() => resolve())));
+(0, node_test_1.describe)('SynapseOCS SDK', () => {
+    (0, node_test_1.it)('manages buckets and stats', async () => {
+        const client = new index_1.SynapseOneClient({ baseUrl: base });
+        const created = await client.ocs.createBucket('media', { quotaBytes: 100 });
+        strict_1.default.equal(created.bucket.name, 'media');
+        const list = await client.ocs.listBuckets({ withStats: true });
+        strict_1.default.equal(list.total, 1);
+        const stats = await client.ocs.bucketStats('media');
+        strict_1.default.equal(stats.objects, 1);
+        const head = await client.ocs.headBucket('media');
+        strict_1.default.equal(head?.['x-ocs-bucket'], 'media');
+        await client.ocs.deleteBucket('media', { force: true });
+        strict_1.default.ok(calls.some((call) => call.path.includes('force=true')));
+    });
+    (0, node_test_1.it)('puts, gets, heads, lists, copies and deletes objects', async () => {
+        const client = new index_1.SynapseOneClient({ baseUrl: base });
+        const object = await client.ocs.putObject('media', 'a.txt', 'hello', { contentType: 'text/plain' });
+        strict_1.default.equal(object.key, 'a.txt');
+        const body = await client.ocs.getObject('media', 'a.txt', { range: 'bytes=0-1' });
+        strict_1.default.equal(Buffer.from(body).toString(), 'hello');
+        const head = await client.ocs.headObject('media', 'a.txt');
+        strict_1.default.equal(head?.etag, 'e');
+        const list = await client.ocs.listObjects('media', { prefix: 'a' });
+        strict_1.default.equal(list.objects[0].key, 'a.txt');
+        const copy = await client.ocs.copyObject('media', { sourceKey: 'a.txt', destinationKey: 'b.txt' });
+        strict_1.default.equal(copy.object.key, 'b.txt');
+        await client.ocs.deleteObject('media', 'a.txt');
+    });
+    (0, node_test_1.it)('presigns and runs multipart uploads', async () => {
+        const client = new index_1.SynapseOneClient({ baseUrl: base });
+        const presigned = await client.ocs.presign('media', 'a.txt', { expiresIn: 60 });
+        strict_1.default.equal(presigned.method, 'GET');
+        const upload = await client.ocs.createMultipart('media', 'a.txt', 'text/plain');
+        strict_1.default.equal(upload.uploadId, 'u1');
+        const part = await client.ocs.uploadPart('media', 'u1', 'a.txt', 1, new Uint8Array([1, 2, 3]));
+        strict_1.default.equal(part.etag, 'p1');
+        const done = await client.ocs.completeMultipart('media', 'u1', 'a.txt', [{ partNumber: 1, etag: 'p1' }]);
+        strict_1.default.equal(done.object.size, 3);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synapseone/sdk",
-  "version": "0.7.1-dev.57",
+  "version": "0.7.1-dev.59",
   "license": "Apache-2.0",
   "description": "synapseone SDK for JavaScript/TypeScript",
   "homepage": "https://synapseone.space",