@rakelabs/evidence-publisher 0.1.0

package/dist/src/http/HttpIpfsClient.js

@@ -0,0 +1,126 @@
+import { buildGatewayUrls } from '../helia/HeliaIpfsClient.js';
+export class HttpIpfsClient {
+    options;
+    apiEndpoint;
+    constructor(options) {
+        this.options = options;
+        const apiEndpoint = options.provider?.url?.trim();
+        if (!apiEndpoint) {
+            throw new Error('HttpIpfsClient requires provider.url');
+        }
+        this.apiEndpoint = apiEndpoint;
+    }
+    async addBytes(bytes, input = {}) {
+        const response = await fetch(this.buildUploadUrl(), {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: this.buildFormData(bytes, input),
+        });
+        const responseBody = await response.text();
+        if (!response.ok) {
+            throw new Error(`HTTP IPFS upload failed with status ${response.status} ${response.statusText}: ${responseBody || '(empty response)'}`);
+        }
+        const cid = extractCid(responseBody, this.options.responseCidFields);
+        if (!cid) {
+            throw new Error('HTTP IPFS upload succeeded but no CID was returned');
+        }
+        return {
+            cid,
+            uri: `ipfs://${cid}`,
+            gatewayUrls: buildGatewayUrls(cid, this.options.gatewayBaseUrls),
+        };
+    }
+    buildUploadUrl() {
+        return appendPathSegment(this.apiEndpoint, this.options.uploadPath ?? '/api/v0/add');
+    }
+    buildFormData(bytes, input) {
+        const fieldName = this.options.uploadFieldName ?? 'file';
+        const fileName = input.fileName?.trim() || 'evidence.bin';
+        const mediaType = input.mediaType?.trim() || 'application/octet-stream';
+        const blobPart = (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+            ? bytes.buffer
+            : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+        const form = new FormData();
+        form.append(fieldName, new Blob([blobPart], { type: mediaType }), fileName);
+        return form;
+    }
+    buildHeaders() {
+        const headers = new Headers();
+        applyAuthHeader(headers, this.options.provider?.auth);
+        for (const [name, value] of Object.entries(this.options.requestHeaders ?? {})) {
+            if (value !== undefined && value !== null) {
+                headers.set(name, value);
+            }
+        }
+        return headers;
+    }
+}
+function extractCid(responseBody, responseCidFields) {
+    const trimmed = responseBody.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const candidates = responseCidFields && responseCidFields.length > 0
+        ? responseCidFields
+        : ['Hash', 'IpfsHash', 'cid', 'CID', 'Cid'];
+    let payload = trimmed;
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            payload = JSON.parse(trimmed);
+        }
+        catch {
+            payload = trimmed;
+        }
+    }
+    if (typeof payload === 'string') {
+        return payload.trim() || undefined;
+    }
+    if (typeof payload === 'object' && payload !== null) {
+        for (const field of candidates) {
+            const value = payload[field];
+            if (typeof value === 'string' && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    return undefined;
+}
+function applyAuthHeader(headers, auth) {
+    if (!auth || auth.type === 'none') {
+        return;
+    }
+    switch (auth.type) {
+        case 'basic': {
+            const token = Buffer.from(`${auth.username}:${auth.password}`, 'utf8').toString('base64');
+            headers.set('Authorization', `Basic ${token}`);
+            return;
+        }
+        case 'bearer':
+            headers.set('Authorization', `Bearer ${auth.token}`);
+            return;
+        case 'header':
+            headers.set(auth.name, auth.value);
+            return;
+        default:
+            return;
+    }
+}
+function appendPathSegment(baseUrl, pathSegment) {
+    const base = baseUrl.trim();
+    const segment = pathSegment.trim();
+    if (!base) {
+        return segment;
+    }
+    if (!segment) {
+        return base;
+    }
+    const baseEndsWithSlash = base.endsWith('/');
+    const segmentStartsWithSlash = segment.startsWith('/');
+    if (baseEndsWithSlash && segmentStartsWithSlash) {
+        return base + segment.slice(1);
+    }
+    if (!baseEndsWithSlash && !segmentStartsWithSlash) {
+        return `${base}/${segment}`;
+    }
+    return base + segment;
+}

package/dist/src/http/HttpIpfsEvidenceStore.d.ts

@@ -0,0 +1,8 @@
+import type { EvidenceStore } from '../storage-types.js';
+import type { EvidenceJsonDocument, PublishedEvidenceDocument } from '../types.js';
+import { HttpIpfsClient, type HttpIpfsClientOptions } from './HttpIpfsClient.js';
+export declare class HttpIpfsEvidenceStore implements EvidenceStore {
+    private readonly client;
+    constructor(options: HttpIpfsClientOptions | HttpIpfsClient);
+    putEvidenceDocument(document: EvidenceJsonDocument): Promise<PublishedEvidenceDocument>;
+}

package/dist/src/http/HttpIpfsEvidenceStore.js

@@ -0,0 +1,19 @@
+import { EvidenceHasher } from '../EvidenceHasher.js';
+import { HttpIpfsClient } from './HttpIpfsClient.js';
+export class HttpIpfsEvidenceStore {
+    client;
+    constructor(options) {
+        this.client = options instanceof HttpIpfsClient ? options : new HttpIpfsClient(options);
+    }
+    async putEvidenceDocument(document) {
+        const added = await this.client.addBytes(EvidenceHasher.serialize(document), {
+            fileName: 'evidence.json',
+            mediaType: 'application/json',
+        });
+        return {
+            cid: added.cid,
+            uri: added.uri,
+            gatewayUrls: added.gatewayUrls,
+        };
+    }
+}

package/dist/src/http/HttpMultipartUploadClient.d.ts

@@ -0,0 +1,36 @@
+import type { RequestContext, RequestFields, UploadRequest } from '../types.js';
+import type { ContentAddResult } from '../storage-types.js';
+export type HttpMultipartUploadInput = Partial<Omit<UploadRequest, 'file'>> & {
+    file: Uint8Array;
+};
+export interface HttpMultipartUploadClientOptions<RequestModel = UploadRequest> extends Partial<RequestContext> {
+    providerUrl?: string;
+    gatewayBaseUrls?: string[];
+    /** Upload endpoint path relative to provider.url. Defaults to /files. */
+    requestPath?: string;
+    /** Multipart field name expected by the provider. Defaults to file. */
+    fileFieldName?: string;
+    /** Client-level default provider-specific fields, merged with per-request fields. */
+    fields?: RequestFields;
+    /** Candidate JSON field names used to extract a CID from the response. */
+    responseCidFields?: string[];
+    /** Build a typed request model before serialization. Defaults to the UploadRequest itself. */
+    buildRequestModel?: (input: UploadRequest) => RequestModel;
+    /** Serialize the request model to the wire body. Defaults to multipart/form-data. */
+    serializeRequestModel?: (request: RequestModel) => BodyInit;
+    /** Parse a CID out of the response model. */
+    parseResponse?: (responseBody: unknown) => string | undefined;
+}
+export declare class HttpMultipartUploadClient<RequestModel = UploadRequest> {
+    private readonly options;
+    private readonly apiEndpoint;
+    constructor(options: HttpMultipartUploadClientOptions<RequestModel>);
+    upload(request: UploadRequest): Promise<ContentAddResult>;
+    addBytes(bytes: Uint8Array, input?: Omit<HttpMultipartUploadInput, 'file'>): Promise<ContentAddResult>;
+    private publish;
+    private buildRequestUrl;
+    private buildHeaders;
+    private buildDefaultFormData;
+    private mergeHeaders;
+    private mergeFields;
+}

package/dist/src/http/HttpMultipartUploadClient.js

@@ -0,0 +1,183 @@
+import { buildGatewayUrls } from '../helia/HeliaIpfsClient.js';
+export class HttpMultipartUploadClient {
+    options;
+    apiEndpoint;
+    constructor(options) {
+        this.options = options;
+        const apiEndpoint = options.providerUrl?.trim();
+        if (!apiEndpoint && !options.requestPath) {
+            throw new Error('HttpMultipartUploadClient requires providerUrl or requestPath');
+        }
+        this.apiEndpoint = apiEndpoint ?? '';
+    }
+    async upload(request) {
+        return this.publish(request);
+    }
+    async addBytes(bytes, input = {}) {
+        const request = {
+            auth: input.auth ?? this.options.auth ?? { type: 'none' },
+            headers: this.mergeHeaders(input.headers),
+            fields: this.mergeFields(input.fields),
+            file: bytes,
+            fileName: input.fileName,
+            mediaType: input.mediaType,
+        };
+        return this.publish(request);
+    }
+    async publish(request) {
+        const model = this.options.buildRequestModel ? this.options.buildRequestModel(request) : request;
+        const response = await fetch(this.buildRequestUrl(), {
+            method: 'POST',
+            headers: this.buildHeaders(request),
+            body: this.options.serializeRequestModel ? this.options.serializeRequestModel(model) : this.buildDefaultFormData(request),
+        });
+        const responseText = await response.text();
+        if (!response.ok) {
+            throw new Error(`HTTP multipart upload failed with status ${response.status} ${response.statusText}: ${responseText || '(empty response)'}`);
+        }
+        const cid = this.options.parseResponse?.(parseJsonIfPossible(responseText)) ?? extractCid(responseText, this.options.responseCidFields);
+        if (!cid) {
+            throw new Error('HTTP multipart upload succeeded but no CID was returned');
+        }
+        return {
+            cid,
+            uri: `ipfs://${cid}`,
+            gatewayUrls: buildGatewayUrls(cid, this.options.gatewayBaseUrls),
+        };
+    }
+    buildRequestUrl() {
+        return this.apiEndpoint ? appendPathSegment(this.apiEndpoint, this.options.requestPath ?? '') : (this.options.requestPath ?? '');
+    }
+    buildHeaders(request) {
+        const headers = new Headers();
+        applyAuthHeader(headers, request.auth ?? this.options.auth ?? { type: 'none' });
+        for (const source of [this.options.headers, request.headers]) {
+            for (const [name, value] of Object.entries(source ?? {})) {
+                if (value !== undefined && value !== null) {
+                    headers.set(name, value);
+                }
+            }
+        }
+        return headers;
+    }
+    buildDefaultFormData(request) {
+        const fieldName = this.options.fileFieldName ?? 'file';
+        const fileName = request.fileName?.trim() || 'evidence.bin';
+        const mediaType = request.mediaType?.trim() || 'application/octet-stream';
+        const blobPart = (request.file.byteOffset === 0 && request.file.byteLength === request.file.buffer.byteLength
+            ? request.file.buffer
+            : request.file.buffer.slice(request.file.byteOffset, request.file.byteOffset + request.file.byteLength));
+        const form = new FormData();
+        form.append(fieldName, new Blob([blobPart], { type: mediaType }), fileName);
+        for (const [name, value] of Object.entries(request.fields ?? {})) {
+            appendFieldValue(form, name, value);
+        }
+        return form;
+    }
+    mergeHeaders(headers) {
+        return { ...(this.options.headers ?? {}), ...(headers ?? {}) };
+    }
+    mergeFields(fields) {
+        return { ...(this.options.fields ?? {}), ...(fields ?? {}) };
+    }
+}
+function extractCid(responseBody, responseCidFields) {
+    const trimmed = responseBody.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const candidates = responseCidFields && responseCidFields.length > 0
+        ? responseCidFields
+        : ['Hash', 'IpfsHash', 'cid', 'CID', 'Cid'];
+    let payload = trimmed;
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            payload = JSON.parse(trimmed);
+        }
+        catch {
+            payload = trimmed;
+        }
+    }
+    if (typeof payload === 'string') {
+        return payload.trim() || undefined;
+    }
+    if (typeof payload === 'object' && payload !== null) {
+        const record = payload;
+        const nested = asRecord(record.data) ?? record;
+        for (const field of candidates) {
+            const value = nested[field];
+            if (typeof value === 'string' && value.trim()) {
+                return value.trim();
+            }
+        }
+    }
+    return undefined;
+}
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function parseJsonIfPossible(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function appendFieldValue(form, name, value) {
+    if (value === undefined || value === null) {
+        return;
+    }
+    if (typeof value === 'string') {
+        form.append(name, value);
+        return;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        form.append(name, String(value));
+        return;
+    }
+    form.append(name, JSON.stringify(value));
+}
+function applyAuthHeader(headers, auth) {
+    switch (auth.type) {
+        case 'none':
+            return;
+        case 'basic': {
+            const token = Buffer.from(`${auth.username}:${auth.password}`, 'utf8').toString('base64');
+            headers.set('Authorization', `Basic ${token}`);
+            return;
+        }
+        case 'bearer':
+            headers.set('Authorization', `Bearer ${auth.token}`);
+            return;
+        case 'header':
+            headers.set(auth.name, auth.value);
+            return;
+    }
+}
+function appendPathSegment(baseUrl, pathSegment) {
+    const base = baseUrl.trim();
+    const segment = pathSegment.trim();
+    if (!base) {
+        return segment;
+    }
+    if (!segment) {
+        return base;
+    }
+    const baseEndsWithSlash = base.endsWith('/');
+    const segmentStartsWithSlash = segment.startsWith('/');
+    if (baseEndsWithSlash && segmentStartsWithSlash) {
+        return base + segment.slice(1);
+    }
+    if (!baseEndsWithSlash && !segmentStartsWithSlash) {
+        return `${base}/${segment}`;
+    }
+    return base + segment;
+}

package/dist/src/http/HttpPinByCidClient.d.ts

@@ -0,0 +1,23 @@
+import type { RequestContext, PinByCidRequest } from '../types.js';
+export interface HttpPinByCidClientOptions extends Partial<RequestContext> {
+    providerUrl?: string;
+    gatewayBaseUrls?: string[];
+    /** Pin-by-CID endpoint path relative to provider.url. Defaults to /files/public/pin_by_cid. */
+    requestPath?: string;
+}
+export interface HttpPinByCidResult {
+    status: number;
+    responseText: string;
+    responseBody: unknown;
+    cid?: string;
+    pinId?: string;
+}
+export declare class HttpPinByCidClient {
+    private readonly options;
+    private readonly apiEndpoint;
+    constructor(options: HttpPinByCidClientOptions);
+    pinByCid(input: PinByCidRequest): Promise<HttpPinByCidResult>;
+    private buildRequestUrl;
+    private buildRequestBody;
+    private buildHeaders;
+}

package/dist/src/http/HttpPinByCidClient.js

@@ -0,0 +1,137 @@
+export class HttpPinByCidClient {
+    options;
+    apiEndpoint;
+    constructor(options) {
+        this.options = options;
+        this.apiEndpoint = options.providerUrl?.trim() ?? '';
+    }
+    async pinByCid(input) {
+        const cid = input.cid.trim();
+        if (!cid) {
+            throw new Error('HttpPinByCidClient requires input.cid');
+        }
+        const response = await fetch(this.buildRequestUrl(), {
+            method: 'POST',
+            headers: this.buildHeaders(input),
+            body: JSON.stringify(this.buildRequestBody({ ...input, cid })),
+        });
+        const responseText = await response.text();
+        if (!response.ok) {
+            throw new Error(`HTTP pin-by-CID failed with status ${response.status} ${response.statusText}: ${responseText || '(empty response)'}`);
+        }
+        const responseBody = parseJsonIfPossible(responseText);
+        const extracted = extractPinByCidMetadata(responseBody);
+        return {
+            status: response.status,
+            responseText,
+            responseBody,
+            ...extracted,
+        };
+    }
+    buildRequestUrl() {
+        return appendPathSegment(this.apiEndpoint, this.options.requestPath ?? '/files/public/pin_by_cid');
+    }
+    buildRequestBody(input) {
+        const body = {
+            cid: input.cid,
+        };
+        for (const [name, value] of Object.entries(input.fields ?? {})) {
+            body[name] = value;
+        }
+        return body;
+    }
+    buildHeaders(input) {
+        const headers = new Headers({
+            'content-type': 'application/json',
+        });
+        applyAuthHeader(headers, input.auth ?? this.options.auth ?? { type: 'none' });
+        for (const [name, value] of Object.entries(this.options.headers ?? {})) {
+            if (value !== undefined && value !== null) {
+                headers.set(name, value);
+            }
+        }
+        for (const [name, value] of Object.entries(input.headers ?? {})) {
+            if (value !== undefined && value !== null) {
+                headers.set(name, value);
+            }
+        }
+        return headers;
+    }
+}
+function parseJsonIfPossible(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+function extractPinByCidMetadata(responseBody) {
+    if (typeof responseBody !== 'object' || responseBody === null) {
+        return {};
+    }
+    const root = responseBody;
+    const data = asRecord(root.data) ?? root;
+    return {
+        cid: readStringField(data, ['cid', 'CID', 'content_cid']),
+        pinId: readStringField(data, ['id', 'pinId', 'pin_id']),
+    };
+}
+function asRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function readStringField(record, names) {
+    for (const name of names) {
+        const value = record[name];
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function applyAuthHeader(headers, auth) {
+    if (!auth || auth.type === 'none') {
+        return;
+    }
+    switch (auth.type) {
+        case 'basic': {
+            const token = Buffer.from(`${auth.username}:${auth.password}`, 'utf8').toString('base64');
+            headers.set('Authorization', `Basic ${token}`);
+            return;
+        }
+        case 'bearer':
+            headers.set('Authorization', `Bearer ${auth.token}`);
+            return;
+        case 'header':
+            headers.set(auth.name, auth.value);
+            return;
+        default:
+            return;
+    }
+}
+function appendPathSegment(baseUrl, pathSegment) {
+    const base = baseUrl.trim();
+    const segment = pathSegment.trim();
+    if (!base) {
+        return segment;
+    }
+    if (!segment) {
+        return base;
+    }
+    const baseEndsWithSlash = base.endsWith('/');
+    const segmentStartsWithSlash = segment.startsWith('/');
+    if (baseEndsWithSlash && segmentStartsWithSlash) {
+        return base + segment.slice(1);
+    }
+    if (!baseEndsWithSlash && !segmentStartsWithSlash) {
+        return `${base}/${segment}`;
+    }
+    return base + segment;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export type { RulingOptionType, CourtEncodingVersion, RulingOptions, MetaEvidence, MetaEvidenceDraft, ManualMetaEvidencePublishRequest, AssistedMetaEvidencePublishRequest, MetaEvidencePublishRequest, MetaEvidencePublishResult, EvidenceJson, EvidenceDraft, EvidencePublishRequest, EvidencePublishResult, PublishedEvidenceDocument, RemotePinningConfig, } from './types.js';
+export type { AttachmentStore, EvidenceStore, MetaEvidenceStore } from './storage-types.js';
+export type { EvidencePublisherFactoryOptions, MetaEvidencePublisherFactoryOptions } from './EvidencePublisherFactory.js';
+export { EvidencePublisher } from './EvidencePublisher.js';
+export { MetaEvidencePublisher } from './MetaEvidencePublisher.js';
+export { MetaEvidenceJsonBuilder } from './MetaEvidenceJsonBuilder.js';
+export { createEvidencePublisher, createMetaEvidencePublisher } from './EvidencePublisherFactory.js';

package/dist/src/index.js

@@ -0,0 +1,5 @@
+// ─── Main publishers ──────────────────────────────────────────────────────────
+export { EvidencePublisher } from './EvidencePublisher.js';
+export { MetaEvidencePublisher } from './MetaEvidencePublisher.js';
+export { MetaEvidenceJsonBuilder } from './MetaEvidenceJsonBuilder.js';
+export { createEvidencePublisher, createMetaEvidencePublisher } from './EvidencePublisherFactory.js';

package/dist/src/storage-types.d.ts

@@ -0,0 +1,21 @@
+import type { ProviderConfig, PinningConfig } from './config.js';
+import type { Attachment, EvidenceJsonDocument, MetaEvidence, PublishedAttachment, PublishedEvidenceDocument } from './types.js';
+export interface ContentPublishOptions {
+    provider?: ProviderConfig;
+    pinning?: PinningConfig;
+    gatewayBaseUrls?: string[];
+}
+export interface ContentAddResult {
+    cid: string;
+    uri: string;
+    gatewayUrls?: string[];
+}
+export interface AttachmentStore {
+    putAttachment(input: Attachment): Promise<PublishedAttachment>;
+}
+export interface EvidenceStore {
+    putEvidenceDocument(document: EvidenceJsonDocument): Promise<PublishedEvidenceDocument>;
+}
+export interface MetaEvidenceStore {
+    putMetaEvidenceDocument(document: MetaEvidence): Promise<PublishedEvidenceDocument>;
+}

package/dist/src/storage-types.js

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