@oino-ts/blob 1.0.0

package/dist/esm/OINOBlob.js

@@ -0,0 +1,190 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { OINODataSource, OINOQueryBooleanOperation, OINOQueryComparison, OINOQueryNullCheck } from "@oino-ts/common";
+const BLOB_LIKE_ESCAPE_REGEX = /[.*+?^${}()|[\]\\]/g;
+const BLOB_LIKE_PERCENT_REGEX = /%/g;
+const BLOB_LIKE_UNDERSCORE_REGEX = /_/g;
+/**
+ * Abstract base class for blob storage backends.  Subclasses implement
+ * the two core operations (`listEntries` and `fetchEntry`) for a specific
+ * provider (e.g. Azure Blob Storage, S3, …).
+ *
+ * The SQL-formatting methods inherited from `OINODataSource` are not used
+ * by blob operations; they are implemented here as passthrough stubs so
+ * that the blob datasource can still be composed with `OINODataField`.
+ */
+export class OINOBlob extends OINODataSource {
+    blobParams;
+    /** Container / bucket name */
+    name;
+    /**
+     * Constructor for `OINOBlob`.
+     * @param params blob storage connection parameters
+     */
+    constructor(params) {
+        super();
+        this.blobParams = { ...params };
+        this.name = this.blobParams.container;
+    }
+    // ── OINODataSource passthrough stubs ──────────────────────────────────
+    // These are required by the abstract base class but are not meaningful
+    // for blob storage.  They return sensible no-op values so that
+    // OINODataField instances created by OINOBlobDataModel can function
+    // correctly for serialisation purposes.
+    printTableName(name) {
+        return name;
+    }
+    printColumnName(name) {
+        return name;
+    }
+    printCellAsValue(cellValue, _sqlType) {
+        if (cellValue === null || cellValue === undefined) {
+            return "";
+        }
+        if (cellValue instanceof Date) {
+            return cellValue.toISOString();
+        }
+        return String(cellValue);
+    }
+    printStringValue(s) {
+        return s;
+    }
+    parseValueAsCell(v, nativeType) {
+        if (nativeType === "DATETIME" && typeof v === "string" && v !== "") {
+            return new Date(v);
+        }
+        return v;
+    }
+    // ── Blob-specific filter helper ───────────────────────────────────────
+    /**
+     * Test whether a blob entry matches an `OINOQueryFilter` predicate.
+     * Used for in-memory (result) filtering when the storage backend cannot
+     * translate the predicate to a native query.
+     *
+     * @param entry blob entry to test
+     * @param filter filter predicate to evaluate
+     */
+    static matchesEntry(entry, filter) {
+        if (filter.isEmpty())
+            return true;
+        const op = filter.operator;
+        if (op === OINOQueryBooleanOperation.and) {
+            return OINOBlob.matchesEntry(entry, filter.leftSide) &&
+                OINOBlob.matchesEntry(entry, filter.rightSide);
+        }
+        if (op === OINOQueryBooleanOperation.or) {
+            return OINOBlob.matchesEntry(entry, filter.leftSide) ||
+                OINOBlob.matchesEntry(entry, filter.rightSide);
+        }
+        if (op === OINOQueryBooleanOperation.not) {
+            return !OINOBlob.matchesEntry(entry, filter.rightSide);
+        }
+        const fieldName = filter.leftSide;
+        const compareValue = filter.rightSide;
+        let fieldValue;
+        switch (fieldName) {
+            case "name":
+                fieldValue = entry.name;
+                break;
+            case "etag":
+                fieldValue = entry.etag;
+                break;
+            case "lastModified":
+                fieldValue = entry.lastModified;
+                break;
+            case "contentLength":
+                fieldValue = entry.contentLength;
+                break;
+            case "contentType":
+                fieldValue = entry.contentType;
+                break;
+            default: return true;
+        }
+        if (op === OINOQueryNullCheck.isnull)
+            return fieldValue === null;
+        if (op === OINOQueryNullCheck.isNotNull)
+            return fieldValue !== null;
+        if (fieldValue === null)
+            return false;
+        if (fieldValue instanceof Date) {
+            const ms = fieldValue.getTime();
+            const cmpMs = new Date(compareValue).getTime();
+            switch (op) {
+                case OINOQueryComparison.lt: return ms < cmpMs;
+                case OINOQueryComparison.le: return ms <= cmpMs;
+                case OINOQueryComparison.eq: return ms === cmpMs;
+                case OINOQueryComparison.ne: return ms !== cmpMs;
+                case OINOQueryComparison.ge: return ms >= cmpMs;
+                case OINOQueryComparison.gt: return ms > cmpMs;
+                default: return true;
+            }
+        }
+        if (typeof fieldValue === "number") {
+            const cmpNum = Number(compareValue);
+            switch (op) {
+                case OINOQueryComparison.lt: return fieldValue < cmpNum;
+                case OINOQueryComparison.le: return fieldValue <= cmpNum;
+                case OINOQueryComparison.eq: return fieldValue === cmpNum;
+                case OINOQueryComparison.ne: return fieldValue !== cmpNum;
+                case OINOQueryComparison.ge: return fieldValue >= cmpNum;
+                case OINOQueryComparison.gt: return fieldValue > cmpNum;
+                default: return true;
+            }
+        }
+        const strValue = String(fieldValue);
+        switch (op) {
+            case OINOQueryComparison.lt: return strValue < compareValue;
+            case OINOQueryComparison.le: return strValue <= compareValue;
+            case OINOQueryComparison.eq: return strValue === compareValue;
+            case OINOQueryComparison.ne: return strValue !== compareValue;
+            case OINOQueryComparison.ge: return strValue >= compareValue;
+            case OINOQueryComparison.gt: return strValue > compareValue;
+            case OINOQueryComparison.like: {
+                const escaped = compareValue
+                    .replace(BLOB_LIKE_ESCAPE_REGEX, "\\$&")
+                    .replace(BLOB_LIKE_PERCENT_REGEX, ".*")
+                    .replace(BLOB_LIKE_UNDERSCORE_REGEX, ".");
+                return new RegExp("^" + escaped + "$", "i").test(strValue);
+            }
+            default: return true;
+        }
+    }
+    /**
+     * Extract a blob/object name prefix from the filter that can be forwarded
+     * to the storage backend as a server-side query optimisation.
+     *
+     * Only two cases translate to a prefix:
+     * - `(name)-eq(value)`        → exact name match (use as prefix)
+     * - `(name)-like(prefix%)`    → trailing-wildcard prefix match
+     *
+     * AND-combined filters are explored recursively so that a name constraint
+     * nested inside a larger AND predicate is still extracted.
+     *
+     * @param filter filter to inspect
+     */
+    static extractNamePrefix(filter) {
+        if (filter.isEmpty())
+            return undefined;
+        const op = filter.operator;
+        if (typeof filter.leftSide === "string" && filter.leftSide === "name") {
+            if (op === OINOQueryComparison.eq) {
+                return filter.rightSide;
+            }
+            if (op === OINOQueryComparison.like) {
+                const pattern = filter.rightSide;
+                const body = pattern.slice(0, -1);
+                if (pattern.endsWith("%") && !body.includes("%") && !body.includes("_")) {
+                    return body;
+                }
+            }
+        }
+        if (op === OINOQueryBooleanOperation.and) {
+            return OINOBlob.extractNamePrefix(filter.leftSide) ??
+                OINOBlob.extractNamePrefix(filter.rightSide);
+        }
+        return undefined;
+    }
+}

package/dist/esm/OINOBlobApi.js

@@ -0,0 +1,175 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { OINOApi, OINOApiRequest, OINOApiResult, OINOModelSet, OINOContentType, OINOLog, OINO_ERROR_PREFIX } from "@oino-ts/common";
+export class OINOBlobApiResult extends OINOApiResult {
+    /** Binary content of the blob (for GET with id) */
+    blobData;
+    /** Content-Type of the blob (for GET with id) */
+    blobDataType;
+    constructor(request, data, blobData, blobDataType) {
+        super(request, data);
+        this.blobData = blobData;
+        this.blobDataType = blobDataType;
+    }
+    async writeApiResponse(headers = {}) {
+        if (this.blobData) {
+            const response_headers = new Headers(headers);
+            response_headers.set("Content-Length", this.blobData.length.toString());
+            if (this.blobDataType) {
+                response_headers.set("Content-Type", this.blobDataType);
+            }
+            if (this.request.responseDownload) {
+                response_headers.set("Content-Disposition", `attachment; filename="${this.request.responseDownload}"`);
+            }
+            else {
+                response_headers.set("Content-Disposition", "inline");
+            }
+            return new Response(this.blobData, {
+                status: this.status,
+                statusText: this.statusText,
+                headers: response_headers
+            });
+        }
+        else {
+            return super.writeApiResponse(headers);
+        }
+    }
+}
+/**
+ * REST API for blob storage.
+ *
+ * Supports two GET variants:
+ * - **GET without id** – lists all blobs under the configured prefix and
+ *   returns the metadata as JSON (or CSV) using `OINOModelSet`.
+ * - **GET with id** – downloads the named blob as a binary HTTP response
+ *   with the blob's own `Content-Type`.
+ *
+ * All other HTTP methods return `405 Method Not Allowed`.
+ */
+export class OINOBlobApi extends OINOApi {
+    /** Blob storage backend */
+    blob;
+    /** Blob-specific data model (populated by `initializeDatamodel`) */
+    blobDatamodel = null;
+    /**
+     * Constructor.
+     *
+     * NOTE: `initializeDatamodel` (or `OINOBlobFactory.createApi`) must be
+     * called before the first request is dispatched.
+     *
+     * @param blob blob storage backend
+     * @param params API parameters (`tableName` is used as the blob prefix)
+     */
+    constructor(blob, params) {
+        super(blob, params);
+        this.blob = blob;
+    }
+    /**
+     * Attach the static blob data model and mark the API as initialised.
+     *
+     * @param datamodel `OINOBlobDataModel` instance for this API
+     */
+    initializeDatamodel(datamodel) {
+        this.blobDatamodel = datamodel;
+        this.datamodel = datamodel;
+        this.initialized = true;
+    }
+    // ── OINOApi abstract implementations ─────────────────────────────────
+    async doApiRequest(request) {
+        if (!this.initialized) {
+            throw new Error(OINO_ERROR_PREFIX + ": OINOBlobApi is not initialized yet!");
+        }
+        OINOLog.debug("@oino-ts/blob", "OINOBlobApi", "doApiRequest", "Request", { method: request.method, id: request.rowId });
+        const result = new OINOBlobApiResult(request);
+        if (request.method === "GET") {
+            if (!request.rowId) {
+                // ── List blobs ───────────────────────────────────────────────
+                try {
+                    const entries = await this.blob.listEntries(request.queryParams?.filter);
+                    const dataset = this.blobDatamodel.entriesToDataset(entries);
+                    result.data = new OINOModelSet(this.datamodel, dataset, request.queryParams);
+                }
+                catch (e) {
+                    result.setError(500, "Error listing blobs: " + e.message, "DoGet");
+                    OINOLog.exception("@oino-ts/blob", "OINOBlobApi", "doApiRequest", "exception in list request", { message: e.message, stack: e.stack });
+                }
+            }
+            else {
+                // ── Download blob ────────────────────────────────────────────
+                try {
+                    const name = decodeURIComponent(request.rowId);
+                    const fetch_result = await this.blob.fetchEntry(name);
+                    result.blobData = fetch_result.content;
+                    result.blobDataType = fetch_result.contentType;
+                }
+                catch (e) {
+                    result.setError(500, "Error fetching blob: " + e.message, "DoGet");
+                    OINOLog.exception("@oino-ts/blob", "OINOBlobApi", "doApiRequest", "exception in fetch request", { message: e.message, stack: e.stack });
+                }
+            }
+        }
+        else if (request.method === "POST" || request.method === "PUT") {
+            if (!request.rowId) {
+                result.setError(400, "HTTP " + request.method + " method requires an URL ID (blob name)!", "DoRequest");
+            }
+            else {
+                try {
+                    const name = decodeURIComponent(request.rowId);
+                    const content_type = request.headers.get("content-type") ?? "application/octet-stream";
+                    const data = request.rowData;
+                    const content = data instanceof Uint8Array ? data : request.bodyAsBuffer();
+                    await this.blob.uploadEntry(name, content, content_type);
+                }
+                catch (e) {
+                    result.setError(500, "Error uploading blob: " + e.message, "DoPost");
+                    OINOLog.exception("@oino-ts/blob", "OINOBlobApi", "doApiRequest", "exception in upload request", { message: e.message, stack: e.stack });
+                }
+            }
+        }
+        else if (request.method === "DELETE") {
+            if (!request.rowId) {
+                result.setError(400, "HTTP DELETE method requires an URL ID (blob name)!", "DoRequest");
+            }
+            else {
+                try {
+                    const name = decodeURIComponent(request.rowId);
+                    await this.blob.deleteEntry(name);
+                }
+                catch (e) {
+                    result.setError(500, "Error deleting blob: " + e.message, "DoDelete");
+                    OINOLog.exception("@oino-ts/blob", "OINOBlobApi", "doApiRequest", "exception in delete request", { message: e.message, stack: e.stack });
+                }
+            }
+        }
+        else {
+            result.setError(405, "Unsupported HTTP method '" + request.method + "' for OINOBlobApi", "DoRequest");
+        }
+        return result;
+    }
+    async doHttpRequest(request, rowId, rowData, queryParams) {
+        const api_request = OINOApiRequest.fromHttpRequest(request, rowId, rowData, queryParams);
+        return this.doApiRequest(api_request);
+    }
+    async doRequest(method, rowId, rowData, queryParams, contentType = OINOContentType.json) {
+        return this.doApiRequest(new OINOApiRequest({
+            method,
+            rowId,
+            rowData,
+            queryParams,
+            requestType: contentType
+        }));
+    }
+    async doBatchUpdate(method, _rowId, _rowData, _queryParams) {
+        const result = new OINOApiResult(new OINOApiRequest({ method }));
+        result.setError(405, "OINOBlobApi does not support batch updates", "DoBatchUpdate");
+        return result;
+    }
+    async doBatchApiRequest(request) {
+        const result = new OINOApiResult(request);
+        result.setError(405, "OINOBlobApi does not support batch updates", "DoBatchApiRequest");
+        return result;
+    }
+}

package/dist/esm/OINOBlobConstants.js

@@ -0,0 +1,6 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export {};

package/dist/esm/OINOBlobDataModel.js

@@ -0,0 +1,65 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { OINODataModel, OINOMemoryDataset, } from "@oino-ts/common";
+/**
+ * Static data model for blob listings.
+ *
+ * Fields are added by the blob implementation's `initializeApiDatamodel`
+ * method, so the exact set depends on what the storage backend supports.
+ * The canonical order is:
+ *   1. `name`          – full blob name (primary key, string)
+ *   2. `etag`          – entity tag (string)
+ *   3. `lastModified`  – last modification timestamp (datetime)
+ *   4. `contentLength` – size in bytes (number)
+ *   5. `contentType`   – MIME type (string) – omitted when not supported
+ */
+export class OINOBlobDataModel extends OINODataModel {
+    /** Reference to the owning blob API */
+    blobApi;
+    /**
+     * Constructor.  Fields are added externally by the blob implementation
+     * via `initializeApiDatamodel`.
+     *
+     * @param api the `OINOBlobApi` that owns this data model
+     */
+    constructor(api) {
+        super(api);
+        this.blobApi = api;
+    }
+    /**
+     * Convert an array of blob entries into an in-memory dataset whose
+     * columns match the fields present in this model.
+     *
+     * @param entries blob entries from the storage backend
+     */
+    entriesToDataset(entries) {
+        const fieldNames = this.fields.map(f => f.name);
+        const rows = entries.map(e => {
+            const row = [];
+            for (const name of fieldNames) {
+                switch (name) {
+                    case "name":
+                        row.push(e.name);
+                        break;
+                    case "etag":
+                        row.push(e.etag);
+                        break;
+                    case "lastModified":
+                        row.push(e.lastModified);
+                        break;
+                    case "contentLength":
+                        row.push(e.contentLength);
+                        break;
+                    case "contentType":
+                        row.push(e.contentType);
+                        break;
+                }
+            }
+            return row;
+        });
+        return new OINOMemoryDataset(rows);
+    }
+}

package/dist/esm/OINOBlobFactory.js

@@ -0,0 +1,67 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { OINOBlobApi } from "./OINOBlobApi.js";
+/**
+ * Static factory for creating `OINOBlob` instances and `OINOBlobApi` instances
+ * from registered provider classes.
+ *
+ * Usage:
+ * ```ts
+ * OINOBlobFactory.registerBlob("OINOBlobAzureTable", OINOBlobAzureTable)
+ * const blob = await OINOBlobFactory.createBlob({ type: "OINOBlobAzureTable", ... })
+ * const api  = await OINOBlobFactory.createApi(blob, { apiName: "files", tableName: "uploads/" })
+ * ```
+ */
+export class OINOBlobFactory {
+    static _registry = {};
+    /**
+     * Register a blob provider class under the given name.
+     *
+     * @param name name used in `OINOBlobParams.type`
+     * @param blobClass constructor of the provider
+     */
+    static registerBlob(name, blobClass) {
+        this._registry[name] = blobClass;
+    }
+    /**
+     * Create and optionally connect/validate a blob backend from params.
+     *
+     * @param params connection parameters
+     * @param connect if true, calls `connect()` on the backend
+     * @param validate if true, calls `validate()` on the backend
+     */
+    static async createBlob(params, connect = true, validate = true) {
+        const BlobClass = this._registry[params.type];
+        if (!BlobClass) {
+            throw new Error("Unsupported blob type: " + params.type);
+        }
+        const blob = new BlobClass(params);
+        if (connect) {
+            const connect_res = await blob.connect();
+            if (!connect_res.success) {
+                throw new Error("Blob connection failed: " + connect_res.statusText);
+            }
+        }
+        if (validate) {
+            const validate_res = await blob.validate();
+            if (!validate_res.success) {
+                throw new Error("Blob validation failed: " + validate_res.statusText);
+            }
+        }
+        return blob;
+    }
+    /**
+     * Create an `OINOBlobApi` and initialise its data model.
+     *
+     * @param blob blob backend to use
+     * @param params API parameters (`tableName` is used as the blob prefix)
+     */
+    static async createApi(blob, params) {
+        const api = new OINOBlobApi(blob, params);
+        await blob.initializeApiDatamodel(api);
+        return api;
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { OINOBlob } from "./OINOBlob.js";
+export { OINOBlobDataModel } from "./OINOBlobDataModel.js";
+export { OINOBlobFactory } from "./OINOBlobFactory.js";
+export { OINOBlobApi, OINOBlobApiResult } from "./OINOBlobApi.js";

package/dist/types/OINOBlob.d.ts

@@ -0,0 +1,78 @@
+import { OINODataSource, OINODataCell, OINOQueryFilter } from "@oino-ts/common";
+import { OINOBlobParams, OINOBlobEntry, OINOBlobFetchResult } from "./OINOBlobConstants.js";
+/**
+ * Abstract base class for blob storage backends.  Subclasses implement
+ * the two core operations (`listEntries` and `fetchEntry`) for a specific
+ * provider (e.g. Azure Blob Storage, S3, …).
+ *
+ * The SQL-formatting methods inherited from `OINODataSource` are not used
+ * by blob operations; they are implemented here as passthrough stubs so
+ * that the blob datasource can still be composed with `OINODataField`.
+ */
+export declare abstract class OINOBlob extends OINODataSource {
+    protected readonly blobParams: OINOBlobParams;
+    /** Container / bucket name */
+    readonly name: string;
+    /**
+     * Constructor for `OINOBlob`.
+     * @param params blob storage connection parameters
+     */
+    constructor(params: OINOBlobParams);
+    printTableName(name: string): string;
+    printColumnName(name: string): string;
+    printCellAsValue(cellValue: OINODataCell, _sqlType: string): string;
+    printStringValue(s: string): string;
+    parseValueAsCell(v: OINODataCell, nativeType: string): OINODataCell;
+    /**
+     * Test whether a blob entry matches an `OINOQueryFilter` predicate.
+     * Used for in-memory (result) filtering when the storage backend cannot
+     * translate the predicate to a native query.
+     *
+     * @param entry blob entry to test
+     * @param filter filter predicate to evaluate
+     */
+    protected static matchesEntry(entry: OINOBlobEntry, filter: OINOQueryFilter): boolean;
+    /**
+     * Extract a blob/object name prefix from the filter that can be forwarded
+     * to the storage backend as a server-side query optimisation.
+     *
+     * Only two cases translate to a prefix:
+     * - `(name)-eq(value)`        → exact name match (use as prefix)
+     * - `(name)-like(prefix%)`    → trailing-wildcard prefix match
+     *
+     * AND-combined filters are explored recursively so that a name constraint
+     * nested inside a larger AND predicate is still extracted.
+     *
+     * @param filter filter to inspect
+     */
+    protected static extractNamePrefix(filter: OINOQueryFilter): string | undefined;
+    /**
+     * List blob entries, optionally filtered by a query filter.  Implementations
+     * should apply native query filtering where possible and fall back to
+     * in-memory result filtering for predicates that cannot be expressed as a
+     * native query.
+     *
+     * @param filter optional query filter to apply to the results
+     */
+    abstract listEntries(filter?: OINOQueryFilter): Promise<OINOBlobEntry[]>;
+    /**
+     * Fetch the binary content and content-type of a named blob.
+     *
+     * @param name full blob name (path within the container)
+     */
+    abstract fetchEntry(name: string): Promise<OINOBlobFetchResult>;
+    /**
+     * Upload (create or replace) a blob with the given binary content.
+     *
+     * @param name full blob name (path within the container)
+     * @param content binary content to store
+     * @param contentType MIME type of the content (e.g. `"image/jpeg"`)
+     */
+    abstract uploadEntry(name: string, content: Uint8Array, contentType: string): Promise<void>;
+    /**
+     * Delete a named blob.
+     *
+     * @param name full blob name (path within the container)
+     */
+    abstract deleteEntry(name: string): Promise<void>;
+}

package/dist/types/OINOBlobApi.d.ts

@@ -0,0 +1,49 @@
+import { OINOApi, OINOApiParams, OINOApiRequest, OINOApiResult, OINOModelSet, OINOContentType, OINOQueryParams, OINOHttpRequest, type OINOApiData } from "@oino-ts/common";
+import { OINOBlob } from "./OINOBlob.js";
+import { OINOBlobDataModel } from "./OINOBlobDataModel.js";
+export declare class OINOBlobApiResult extends OINOApiResult {
+    /** Binary content of the blob (for GET with id) */
+    blobData?: Uint8Array;
+    /** Content-Type of the blob (for GET with id) */
+    blobDataType?: string;
+    constructor(request: OINOApiRequest, data?: OINOModelSet, blobData?: Uint8Array, blobDataType?: string);
+    writeApiResponse(headers?: Record<string, string>): Promise<Response>;
+}
+/**
+ * REST API for blob storage.
+ *
+ * Supports two GET variants:
+ * - **GET without id** – lists all blobs under the configured prefix and
+ *   returns the metadata as JSON (or CSV) using `OINOModelSet`.
+ * - **GET with id** – downloads the named blob as a binary HTTP response
+ *   with the blob's own `Content-Type`.
+ *
+ * All other HTTP methods return `405 Method Not Allowed`.
+ */
+export declare class OINOBlobApi extends OINOApi {
+    /** Blob storage backend */
+    readonly blob: OINOBlob;
+    /** Blob-specific data model (populated by `initializeDatamodel`) */
+    blobDatamodel: OINOBlobDataModel | null;
+    /**
+     * Constructor.
+     *
+     * NOTE: `initializeDatamodel` (or `OINOBlobFactory.createApi`) must be
+     * called before the first request is dispatched.
+     *
+     * @param blob blob storage backend
+     * @param params API parameters (`tableName` is used as the blob prefix)
+     */
+    constructor(blob: OINOBlob, params: OINOApiParams);
+    /**
+     * Attach the static blob data model and mark the API as initialised.
+     *
+     * @param datamodel `OINOBlobDataModel` instance for this API
+     */
+    initializeDatamodel(datamodel: OINOBlobDataModel): void;
+    doApiRequest(request: OINOApiRequest): Promise<OINOBlobApiResult>;
+    doHttpRequest(request: OINOHttpRequest, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams): Promise<OINOBlobApiResult>;
+    doRequest(method: string, rowId: string, rowData: OINOApiData, queryParams: OINOQueryParams, contentType?: OINOContentType): Promise<OINOBlobApiResult>;
+    doBatchUpdate(method: string, _rowId: string, _rowData: OINOApiData, _queryParams?: OINOQueryParams): Promise<OINOBlobApiResult>;
+    doBatchApiRequest(request: OINOApiRequest): Promise<OINOBlobApiResult>;
+}

package/dist/types/OINOBlobConstants.d.ts

@@ -0,0 +1,37 @@
+import type { OINOBlob } from "./OINOBlob.js";
+/**
+ * Blob class (constructor) type
+ * @param params blob parameters
+ */
+export type OINOBlobConstructor = new (params: OINOBlobParams) => OINOBlob;
+/** Blob storage connection parameters */
+export type OINOBlobParams = {
+    /** Name of the blob class (e.g. OINOBlobAzureTable) */
+    type: string;
+    /** Blob service endpoint URL */
+    url: string;
+    /** Container / bucket name */
+    container: string;
+    /** Provider-specific connection string (e.g. Azure Storage connection string or SAS URL) */
+    connectionStr?: string;
+};
+/** A single blob entry returned by a listing operation */
+export type OINOBlobEntry = {
+    /** Full blob name (path within the container) */
+    name: string;
+    /** Entity tag */
+    etag: string;
+    /** Last modification timestamp */
+    lastModified: Date;
+    /** Size in bytes */
+    contentLength: number;
+    /** MIME content type */
+    contentType: string;
+};
+/** Result of a blob fetch operation */
+export type OINOBlobFetchResult = {
+    /** Raw blob bytes */
+    content: Uint8Array;
+    /** MIME content type of the blob */
+    contentType: string;
+};