@oino-ts/nosql 1.0.0

package/dist/cjs/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINONoSqlApi = exports.OINONoSqlFactory = exports.OINONoSqlDataModel = exports.OINONoSql = void 0;
+var OINONoSql_js_1 = require("./OINONoSql.js");
+Object.defineProperty(exports, "OINONoSql", { enumerable: true, get: function () { return OINONoSql_js_1.OINONoSql; } });
+var OINONoSqlDataModel_js_1 = require("./OINONoSqlDataModel.js");
+Object.defineProperty(exports, "OINONoSqlDataModel", { enumerable: true, get: function () { return OINONoSqlDataModel_js_1.OINONoSqlDataModel; } });
+var OINONoSqlFactory_js_1 = require("./OINONoSqlFactory.js");
+Object.defineProperty(exports, "OINONoSqlFactory", { enumerable: true, get: function () { return OINONoSqlFactory_js_1.OINONoSqlFactory; } });
+var OINONoSqlApi_js_1 = require("./OINONoSqlApi.js");
+Object.defineProperty(exports, "OINONoSqlApi", { enumerable: true, get: function () { return OINONoSqlApi_js_1.OINONoSqlApi; } });

package/dist/esm/OINONoSql.js

@@ -0,0 +1,153 @@
+/*
+ * 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 NOSQL_LIKE_ESCAPE_REGEX = /[.*+?^${}()|[\]\\]/g;
+const NOSQL_LIKE_PERCENT_REGEX = /%/g;
+const NOSQL_LIKE_UNDERSCORE_REGEX = /_/g;
+/**
+ * Abstract base class for NoSQL storage backends.  Subclasses implement
+ * the core CRUD operations for a specific provider (e.g. Azure Table Storage).
+ *
+ * The data model exposed by the API has a fixed set of fields:
+ *   1. `partitionKey`  – partition key (primary key component, string)
+ *   2. `rowKey`        – row key (primary key component, string)
+ *   3. `timestamp`     – last modification timestamp (datetime)
+ *   4. `etag`          – entity tag (string)
+ *   5. `properties`    – all custom entity properties as a JSON string
+ *
+ * The SQL-formatting methods inherited from `OINODataSource` are not used
+ * by nosql operations; they are implemented here as passthrough stubs.
+ */
+export class OINONoSql extends OINODataSource {
+    nosqlParams;
+    /** Table name */
+    name;
+    /**
+     * Whether this backend can auto-generate primary key values when none are
+     * supplied in a POST request.  Defaults to `false`; override in subclasses
+     * that support server-side key generation (e.g. UUID on insert).
+     */
+    supportsAutoKey = false;
+    /**
+     * Constructor for `OINONoSql`.
+     * @param params nosql storage connection parameters
+     */
+    constructor(params) {
+        super();
+        this.nosqlParams = { ...params };
+        this.name = this.nosqlParams.table;
+    }
+    // ── OINODataSource passthrough stubs ──────────────────────────────────
+    printTableName(name) {
+        return name;
+    }
+    printColumnName(name) {
+        return name;
+    }
+    printCellAsValue(cellValue, nativeType) {
+        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;
+    }
+    // ── NoSQL-specific filter helpers ─────────────────────────────────────
+    /**
+     * Test whether a NoSQL 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 nosql 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 OINONoSql.matchesEntry(entry, filter.leftSide) &&
+                OINONoSql.matchesEntry(entry, filter.rightSide);
+        }
+        if (op === OINOQueryBooleanOperation.or) {
+            return OINONoSql.matchesEntry(entry, filter.leftSide) ||
+                OINONoSql.matchesEntry(entry, filter.rightSide);
+        }
+        if (op === OINOQueryBooleanOperation.not) {
+            return !OINONoSql.matchesEntry(entry, filter.rightSide);
+        }
+        const field_name = filter.leftSide;
+        const compare_value = filter.rightSide;
+        let field_value;
+        switch (field_name) {
+            case "timestamp":
+                field_value = entry.timestamp;
+                break;
+            case "etag":
+                field_value = entry.etag;
+                break;
+            default: return true;
+        }
+        if (op === OINOQueryNullCheck.isnull)
+            return field_value === null;
+        if (op === OINOQueryNullCheck.isNotNull)
+            return field_value !== null;
+        if (field_value === null)
+            return false;
+        if (field_value instanceof Date) {
+            const ms = field_value.getTime();
+            const cmp_ms = new Date(compare_value).getTime();
+            switch (op) {
+                case OINOQueryComparison.lt: return ms < cmp_ms;
+                case OINOQueryComparison.le: return ms <= cmp_ms;
+                case OINOQueryComparison.eq: return ms === cmp_ms;
+                case OINOQueryComparison.ne: return ms !== cmp_ms;
+                case OINOQueryComparison.ge: return ms >= cmp_ms;
+                case OINOQueryComparison.gt: return ms > cmp_ms;
+                default: return true;
+            }
+        }
+        const str_value = String(field_value);
+        switch (op) {
+            case OINOQueryComparison.lt: return str_value < compare_value;
+            case OINOQueryComparison.le: return str_value <= compare_value;
+            case OINOQueryComparison.eq: return str_value === compare_value;
+            case OINOQueryComparison.ne: return str_value !== compare_value;
+            case OINOQueryComparison.ge: return str_value >= compare_value;
+            case OINOQueryComparison.gt: return str_value > compare_value;
+            case OINOQueryComparison.like: {
+                const escaped = compare_value
+                    .replace(NOSQL_LIKE_ESCAPE_REGEX, "\\$&")
+                    .replace(NOSQL_LIKE_PERCENT_REGEX, ".*")
+                    .replace(NOSQL_LIKE_UNDERSCORE_REGEX, ".");
+                return new RegExp("^" + escaped + "$", "i").test(str_value);
+            }
+            default: return true;
+        }
+    }
+    /**
+     * Upsert (insert or replace) multiple entities in the most efficient way
+     * the backend supports.  The default implementation loops over
+     * `upsertEntry`; override in subclasses that support native batch writes.
+     *
+     * @param entries entities to upsert
+     */
+    async upsertEntries(entries) {
+        for (const entry of entries) {
+            await this.upsertEntry(entry);
+        }
+    }
+}

package/dist/esm/OINONoSqlApi.js

@@ -0,0 +1,374 @@
+/*
+ * 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, OINOConfig, OINOParser, OINOBenchmark, OINO_ERROR_PREFIX } from "@oino-ts/common";
+/**
+ * REST API for NoSQL table storage.
+ *
+ * Supports the following HTTP methods:
+ * - **GET without id** – lists all entities and returns metadata as JSON.
+ * - **GET with id** – returns a single entity.
+ * - **POST / PUT with id** – upserts an entity; body must be a JSON object
+ *   with a `properties` key containing the custom entity properties.
+ * - **DELETE with id** – deletes the named entity.
+ *
+ * The URL row ID format uses `OINOConfig.OINO_ID_SEPARATOR` to join the
+ * primary key field values, matching the number and order of primary key
+ * fields in the data model (same `_OINOID_` convention as `OINODbApi`).
+ */
+export class OINONoSqlApi extends OINOApi {
+    /** NoSQL storage backend */
+    noSql;
+    /** NoSQL-specific data model (populated by `initializeDatamodel`) */
+    noSqlDatamodel = null;
+    /**
+     * Constructor.
+     *
+     * NOTE: `initializeDatamodel` (or `OINONoSqlFactory.createApi`) must be
+     * called before the first request is dispatched.
+     *
+     * @param noSql nosql storage backend
+     * @param params API parameters
+     */
+    constructor(noSql, params) {
+        if (params.hashidKey) {
+            throw new Error(OINO_ERROR_PREFIX + ": hashid is not supported by OINONoSqlApi (primary keys are strings, not numeric IDs)");
+        }
+        if (params.failOnUpdateOnAutoinc) {
+            throw new Error(OINO_ERROR_PREFIX + ": failOnUpdateOnAutoinc is not supported by OINONoSqlApi (no autoinc fields in NoSQL)");
+        }
+        if (params.returnInsertedIds) {
+            throw new Error(OINO_ERROR_PREFIX + ": returnInsertedIds is not supported by OINONoSqlApi");
+        }
+        super(noSql, params);
+        this.noSql = noSql;
+    }
+    /**
+     * Attach the static nosql data model and mark the API as initialised.
+     *
+     * @param datamodel `OINONoSqlDataModel` instance for this API
+     */
+    initializeDatamodel(datamodel) {
+        this.noSqlDatamodel = datamodel;
+        this.datamodel = datamodel;
+        this.initialized = true;
+    }
+    /**
+     * Parse a `_OINOID_`-formatted row ID into an ordered array of decoded
+     * primary key values using `OINOConfig.parseOINOId`.  Returns `null` when
+     * the number of parts does not match the data model's primary key count.
+     *
+     * @param rowId `_OINOID_`-formatted row ID
+     */
+    _parseRowId(rowId) {
+        if (!this.noSqlDatamodel)
+            return null;
+        const pk_count = this.noSqlDatamodel.filterFields((f) => f.fieldParams.isPrimaryKey).length;
+        const parts = OINOConfig.parseOINOId(rowId);
+        if (parts.length !== pk_count)
+            return null;
+        return parts;
+    }
+    // ── Private helpers ───────────────────────────────────────────────────
+    /**
+     * Validate a data row against API parameters.  Currently checks whether
+     * primary key fields are present when `requirePrimaryKey` is `true`.
+     *
+     * `requirePrimaryKey` is derived at the call-site from:
+     * - `this.params.failOnInsertWithoutKey` when explicitly set, or
+     * - `!this.noSql.supportsAutoKey` as the implementation-specific default.
+     */
+    _validateRow(result, row, requirePrimaryKey) {
+        if (!requirePrimaryKey)
+            return;
+        const pk_fields = this.noSqlDatamodel.filterFields((f) => f.fieldParams.isPrimaryKey);
+        for (let i = 0; i < pk_fields.length; i++) {
+            const field_idx = this.noSqlDatamodel.fields.indexOf(pk_fields[i]);
+            const val = row[field_idx];
+            if (val === undefined || val === null || String(val) === "") {
+                result.setError(405, `Primary key '${pk_fields[i].name}' is missing from the data!`, "_validateRow");
+                return;
+            }
+        }
+    }
+    _parseData(result, request) {
+        let rows = [];
+        const data = request.rowData ?? request.body;
+        try {
+            if (Array.isArray(data)) {
+                rows = data;
+            }
+            else if (data != null) {
+                rows = OINOParser.createRows(this.datamodel, data, request.requestType, request.multipartBoundary);
+            }
+        }
+        catch (e) {
+            result.setError(400, "Invalid data: " + e.message, "_parseData");
+        }
+        return rows;
+    }
+    _rowToEntry(row, pkOverride) {
+        const pk_fields = this.noSqlDatamodel.fields.filter(f => f.fieldParams.isPrimaryKey);
+        const primary_key = pkOverride ?? pk_fields.map(f => {
+            const idx = this.noSqlDatamodel.fields.indexOf(f);
+            return String(row[idx] ?? "");
+        });
+        const properties_idx = this.noSqlDatamodel.fields.findIndex(f => f.name === "properties");
+        const raw = properties_idx >= 0 ? row[properties_idx] : undefined;
+        let properties = {};
+        if (typeof raw === "string") {
+            properties = JSON.parse(raw);
+        }
+        else if ((raw != null) && (typeof raw === "object") && !Array.isArray(raw) && !(raw instanceof Date) && !(raw instanceof Uint8Array)) {
+            properties = raw;
+        }
+        return { primaryKey: primary_key, timestamp: new Date(), etag: "", properties };
+    }
+    // ── Private HTTP method handlers ──────────────────────────────────────
+    async _doGet(result, pkValues, request) {
+        if (!pkValues) {
+            try {
+                const entries = await this.noSql.listEntries(request.queryParams?.filter);
+                const dataset = this.noSqlDatamodel.entriesToDataset(entries);
+                result.data = new OINOModelSet(this.datamodel, dataset, request.queryParams);
+            }
+            catch (e) {
+                result.setError(500, "Error listing nosql entries: " + e.message, "DoGet");
+                OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "_doGet", "exception in list request", { message: e.message, stack: e.stack });
+            }
+        }
+        else {
+            try {
+                const entry = await this.noSql.getEntry(pkValues);
+                if (entry === null) {
+                    result.setError(404, `Entry '${pkValues.join("/")}' not found`, "DoGet");
+                }
+                else {
+                    const dataset = this.noSqlDatamodel.entriesToDataset([entry]);
+                    result.data = new OINOModelSet(this.datamodel, dataset, request.queryParams);
+                }
+            }
+            catch (e) {
+                result.setError(500, "Error fetching nosql entry: " + e.message, "DoGet");
+                OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "_doGet", "exception in get request", { message: e.message, stack: e.stack });
+            }
+        }
+    }
+    async _doPut(result, pkValues, row) {
+        try {
+            await this.noSql.upsertEntry(this._rowToEntry(row, pkValues));
+        }
+        catch (e) {
+            result.setError(500, "Error upserting nosql entry: " + e.message, "DoPut");
+            OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "_doPut", "exception in put request", { message: e.message, stack: e.stack });
+        }
+    }
+    async _doPost(result, rows, pkOverride) {
+        // Validate all rows first and collect valid entries
+        const entries = [];
+        const require_pk = !pkOverride && (this.params.failOnInsertWithoutKey ?? !this.noSql.supportsAutoKey);
+        for (const row of rows) {
+            if (require_pk) {
+                this._validateRow(result, row, true);
+                if (!result.success) {
+                    if (this.params.failOnAnyInvalidRows === false) {
+                        result.setOk();
+                        continue;
+                    }
+                    return;
+                }
+            }
+            entries.push(this._rowToEntry(row, pkOverride));
+        }
+        if (entries.length === 0 && result.success) {
+            result.setError(405, "No valid rows for POST!", "DoPost");
+            return;
+        }
+        // Single batch call — implementations use native bulk APIs where possible
+        try {
+            await this.noSql.upsertEntries(entries);
+        }
+        catch (e) {
+            result.setError(500, "Error upserting nosql entries: " + e.message, "DoPost");
+            OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "_doPost", "exception in post request", { message: e.message, stack: e.stack });
+        }
+    }
+    async _doDelete(result, pkValues) {
+        try {
+            await this.noSql.deleteEntry(pkValues);
+        }
+        catch (e) {
+            result.setError(500, "Error deleting nosql entry: " + e.message, "DoDelete");
+            OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "_doDelete", "exception in delete request", { message: e.message, stack: e.stack });
+        }
+    }
+    // ── OINOApi abstract implementations ─────────────────────────────────
+    async doApiRequest(request) {
+        if (!this.initialized) {
+            throw new Error(OINO_ERROR_PREFIX + ": OINONoSqlApi is not initialized yet!");
+        }
+        OINOLog.debug("@oino-ts/nosql", "OINONoSqlApi", "doApiRequest", "Request", { method: request.method, id: request.rowId });
+        const result = new OINOApiResult(request);
+        let rows = [];
+        if (request.method === "PUT" || request.method === "POST") {
+            rows = this._parseData(result, request);
+        }
+        if (request.method === "GET") {
+            if (request.rowId) {
+                const pk_values = this._parseRowId(request.rowId);
+                if (!pk_values) {
+                    const pk_count = this.noSqlDatamodel.filterFields((f) => f.fieldParams.isPrimaryKey).length;
+                    result.setError(400, `Invalid row ID; expected ${pk_count} key part(s) separated by '${OINOConfig.OINO_ID_SEPARATOR}'`, "DoRequest");
+                }
+                else {
+                    await this._doGet(result, pk_values, request);
+                }
+            }
+            else {
+                await this._doGet(result, null, request);
+            }
+        }
+        else if (request.method === "PUT") {
+            if (!request.rowId) {
+                result.setError(400, "HTTP PUT method requires a URL ID!", "DoRequest");
+            }
+            else if (rows.length !== 1) {
+                result.setError(400, "HTTP PUT method requires exactly one row in the body data!", "DoRequest");
+            }
+            else {
+                const pk_values = this._parseRowId(request.rowId);
+                if (!pk_values) {
+                    const pk_count = this.noSqlDatamodel.filterFields((f) => f.fieldParams.isPrimaryKey).length;
+                    result.setError(400, `Invalid row ID; expected ${pk_count} key part(s) separated by '${OINOConfig.OINO_ID_SEPARATOR}'`, "DoRequest");
+                }
+                else {
+                    await this._doPut(result, pk_values, rows[0]);
+                }
+            }
+        }
+        else if (request.method === "POST") {
+            if (rows.length === 0) {
+                result.setError(400, "HTTP POST method requires at least one row in the body data!", "DoRequest");
+            }
+            else {
+                let pk_override;
+                if (request.rowId) {
+                    if (rows.length !== 1) {
+                        result.setError(400, "HTTP POST with a URL ID requires exactly one row in the body data!", "DoRequest");
+                    }
+                    else {
+                        const pk_values = this._parseRowId(request.rowId);
+                        if (!pk_values) {
+                            const pk_count = this.noSqlDatamodel.filterFields((f) => f.fieldParams.isPrimaryKey).length;
+                            result.setError(400, `Invalid row ID; expected ${pk_count} key part(s) separated by '${OINOConfig.OINO_ID_SEPARATOR}'`, "DoRequest");
+                        }
+                        else {
+                            pk_override = pk_values;
+                        }
+                    }
+                }
+                if (result.success) {
+                    await this._doPost(result, rows, pk_override);
+                }
+            }
+        }
+        else if (request.method === "DELETE") {
+            if (!request.rowId) {
+                result.setError(400, "HTTP DELETE method requires a URL ID!", "DoRequest");
+            }
+            else {
+                const pk_values = this._parseRowId(request.rowId);
+                if (!pk_values) {
+                    const pk_count = this.noSqlDatamodel.filterFields((f) => f.fieldParams.isPrimaryKey).length;
+                    result.setError(400, `Invalid row ID; expected ${pk_count} key part(s) separated by '${OINOConfig.OINO_ID_SEPARATOR}'`, "DoRequest");
+                }
+                else {
+                    await this._doDelete(result, pk_values);
+                }
+            }
+        }
+        else {
+            result.setError(405, "Unsupported HTTP method '" + request.method + "' for OINONoSqlApi", "DoRequest");
+        }
+        return result;
+    }
+    async doBatchUpdate(method, rowId, rowData, queryParams) {
+        return this.doBatchApiRequest(new OINOApiRequest({ method, rowId, rowData, queryParams }));
+    }
+    async doBatchApiRequest(request) {
+        if (!this.initialized) {
+            throw new Error(OINO_ERROR_PREFIX + ": OINONoSqlApi is not initialized yet!");
+        }
+        OINOLog.debug("@oino-ts/nosql", "OINONoSqlApi", "doBatchApiRequest", "Request", { method: request.method });
+        const result = new OINOApiResult(request);
+        if (request.method !== "PUT" && request.method !== "DELETE") {
+            result.setError(405, "Batch API only supports PUT and DELETE methods!", "DoBatchApiRequest");
+            return result;
+        }
+        OINOBenchmark.startMetric("OINONoSqlApi", "doBatchApiRequest." + request.method);
+        const rows = this._parseData(result, request);
+        if (!result.success) {
+            OINOBenchmark.endMetric("OINONoSqlApi", "doBatchApiRequest." + request.method, false);
+            return result;
+        }
+        if (request.method === "PUT") {
+            const entries = [];
+            const require_pk = this.params.failOnInsertWithoutKey ?? !this.noSql.supportsAutoKey;
+            for (const row of rows) {
+                this._validateRow(result, row, require_pk);
+                if (!result.success) {
+                    OINOBenchmark.endMetric("OINONoSqlApi", "doBatchApiRequest." + request.method, false);
+                    return result;
+                }
+                entries.push(this._rowToEntry(row));
+            }
+            if (entries.length === 0) {
+                result.setError(405, "No valid rows for batch PUT!", "DoBatchApiRequest");
+                OINOBenchmark.endMetric("OINONoSqlApi", "doBatchApiRequest." + request.method, false);
+                return result;
+            }
+            try {
+                await this.noSql.upsertEntries(entries);
+            }
+            catch (e) {
+                result.setError(500, "Error batch upserting nosql entries: " + e.message, "DoBatchApiRequest");
+                OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "doBatchApiRequest", "exception in batch put request", { message: e.message, stack: e.stack });
+            }
+        }
+        else {
+            const pk_fields = this.noSqlDatamodel.fields.filter(f => f.fieldParams.isPrimaryKey);
+            for (const row of rows) {
+                const pk_values = pk_fields.map(f => {
+                    const idx = this.noSqlDatamodel.fields.indexOf(f);
+                    return String(row[idx] ?? "");
+                });
+                try {
+                    await this.noSql.deleteEntry(pk_values);
+                }
+                catch (e) {
+                    result.setError(500, "Error batch deleting nosql entry: " + e.message, "DoBatchApiRequest");
+                    OINOLog.exception("@oino-ts/nosql", "OINONoSqlApi", "doBatchApiRequest", "exception in batch delete request", { message: e.message, stack: e.stack });
+                    OINOBenchmark.endMetric("OINONoSqlApi", "doBatchApiRequest." + request.method, false);
+                    return result;
+                }
+            }
+        }
+        OINOBenchmark.endMetric("OINONoSqlApi", "doBatchApiRequest." + request.method, result.success);
+        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
+        }));
+    }
+}

package/dist/esm/OINONoSqlConstants.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/OINONoSqlDataModel.js

@@ -0,0 +1,61 @@
+/*
+ * 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 NoSQL entity listings.
+ *
+ * The canonical field order is determined by the implementation's
+ * `initializeApiDatamodel` call.  Primary key fields are mapped positionally
+ * to `OINONoSqlEntry.primaryKey`, while the remaining fields (`timestamp`,
+ * `etag`, `properties`) are matched by name.
+ */
+export class OINONoSqlDataModel extends OINODataModel {
+    /** Reference to the owning NoSQL API */
+    noSqlApi;
+    /**
+     * Constructor.  Fields are added externally by the nosql implementation
+     * via `initializeApiDatamodel`.
+     *
+     * @param api the `OINONoSqlApi` that owns this data model
+     */
+    constructor(api) {
+        super(api);
+        this.noSqlApi = api;
+    }
+    /**
+     * Convert an array of NoSQL entries into an in-memory dataset whose
+     * columns match the fields present in this model.
+     *
+     * @param entries nosql entries from the storage backend
+     */
+    entriesToDataset(entries) {
+        const pk_fields = this.fields.filter(f => f.fieldParams.isPrimaryKey);
+        const rows = entries.map(e => {
+            const row = [];
+            for (const field of this.fields) {
+                const pk_idx = pk_fields.indexOf(field);
+                if (pk_idx >= 0) {
+                    row.push(e.primaryKey[pk_idx] ?? "");
+                }
+                else {
+                    switch (field.name) {
+                        case "timestamp":
+                            row.push(e.timestamp);
+                            break;
+                        case "etag":
+                            row.push(e.etag);
+                            break;
+                        case "properties":
+                            row.push(JSON.stringify(e.properties));
+                            break;
+                    }
+                }
+            }
+            return row;
+        });
+        return new OINOMemoryDataset(rows);
+    }
+}

package/dist/esm/OINONoSqlFactory.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 { OINONoSqlApi } from "./OINONoSqlApi.js";
+/**
+ * Static factory for creating `OINONoSql` instances and `OINONoSqlApi` instances
+ * from registered provider classes.
+ *
+ * Usage:
+ * ```ts
+ * OINONoSqlFactory.registerNoSql("OINONoSqlAzureTable", OINONoSqlAzureTable)
+ * const nosql = await OINONoSqlFactory.createNoSql({ type: "OINONoSqlAzureTable", ... })
+ * const api   = await OINONoSqlFactory.createApi(nosql, { apiName: "entities", tableName: "myTable" })
+ * ```
+ */
+export class OINONoSqlFactory {
+    static _registry = {};
+    /**
+     * Register a nosql provider class under the given name.
+     *
+     * @param name name used in `OINONoSqlParams.type`
+     * @param noSqlClass constructor of the provider
+     */
+    static registerNoSql(name, noSqlClass) {
+        this._registry[name] = noSqlClass;
+    }
+    /**
+     * Create and optionally connect/validate a nosql 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 createNoSql(params, connect = true, validate = true) {
+        const no_sql_class = this._registry[params.type];
+        if (!no_sql_class) {
+            throw new Error("Unsupported nosql type: " + params.type);
+        }
+        const nosql = new no_sql_class(params);
+        if (connect) {
+            const connect_res = await nosql.connect();
+            if (!connect_res.success) {
+                throw new Error("NoSql connection failed: " + connect_res.statusText);
+            }
+        }
+        if (validate) {
+            const validate_res = await nosql.validate();
+            if (!validate_res.success) {
+                throw new Error("NoSql validation failed: " + validate_res.statusText);
+            }
+        }
+        return nosql;
+    }
+    /**
+     * Create an `OINONoSqlApi` and initialise its data model.
+     *
+     * @param noSql nosql backend to use
+     * @param params API parameters
+     */
+    static async createApi(noSql, params) {
+        const api = new OINONoSqlApi(noSql, params);
+        await noSql.initializeApiDatamodel(api);
+        return api;
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { OINONoSql } from "./OINONoSql.js";
+export { OINONoSqlDataModel } from "./OINONoSqlDataModel.js";
+export { OINONoSqlFactory } from "./OINONoSqlFactory.js";
+export { OINONoSqlApi } from "./OINONoSqlApi.js";