@oino-ts/nosql 1.0.0

package/src/OINONoSqlApi.ts

@@ -0,0 +1,414 @@
+/*
+ * 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,
+    OINOApiParams,
+    OINOApiRequest,
+    OINOApiResult,
+    OINOModelSet,
+    OINOContentType,
+    OINOQueryParams,
+    OINOHttpRequest,
+    type OINOApiData,
+    type OINODataField,
+    type OINODataRow,
+    OINOLog,
+    OINOConfig,
+    OINOParser,
+    OINOBenchmark,
+    OINO_ERROR_PREFIX
+} from "@oino-ts/common"
+import { OINONoSql } from "./OINONoSql.js"
+import { OINONoSqlDataModel } from "./OINONoSqlDataModel.js"
+import { OINONoSqlEntry } from "./OINONoSqlConstants.js"
+
+/**
+ * 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 */
+    readonly noSql: OINONoSql
+
+    /** NoSQL-specific data model (populated by `initializeDatamodel`) */
+    noSqlDatamodel: OINONoSqlDataModel | null = 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: OINONoSql, params: OINOApiParams) {
+        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: OINONoSqlDataModel): void {
+        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
+     */
+    private _parseRowId(rowId: string): string[] | null {
+        if (!this.noSqlDatamodel) return null
+        const pk_count = this.noSqlDatamodel.filterFields((f: OINODataField) => 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.
+     */
+    private _validateRow(result: OINOApiResult, row: OINODataRow, requirePrimaryKey: boolean): void {
+        if (!requirePrimaryKey) return
+        const pk_fields = this.noSqlDatamodel!.filterFields((f: OINODataField) => 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
+            }
+        }
+    }
+
+    private _parseData(result: OINOApiResult, request: OINOApiRequest): OINODataRow[] {
+        let rows: OINODataRow[] = []
+        const data = request.rowData ?? request.body
+        try {
+            if (Array.isArray(data)) {
+                rows = data as OINODataRow[]
+            } else if (data != null) {
+                rows = OINOParser.createRows(this.datamodel!, data, request.requestType, request.multipartBoundary)
+            }
+        } catch (e: any) {
+            result.setError(400, "Invalid data: " + e.message, "_parseData")
+        }
+        return rows
+    }
+
+    private _rowToEntry(row: OINODataRow, pkOverride?: string[]): OINONoSqlEntry {
+        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: Record<string, unknown> = {}
+        if (typeof raw === "string") {
+            properties = JSON.parse(raw) as Record<string, unknown>
+        } else if ((raw != null) && (typeof raw === "object") && !Array.isArray(raw) && !(raw instanceof Date) && !(raw instanceof Uint8Array)) {
+            properties = raw as Record<string, unknown>
+        }
+        return { primaryKey: primary_key, timestamp: new Date(), etag: "", properties }
+    }
+
+    // ── Private HTTP method handlers ──────────────────────────────────────
+
+    private async _doGet(result: OINOApiResult, pkValues: string[] | null, request: OINOApiRequest): Promise<void> {
+        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: any) {
+                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: any) {
+                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 })
+            }
+        }
+    }
+
+    private async _doPut(result: OINOApiResult, pkValues: string[], row: OINODataRow): Promise<void> {
+        try {
+            await this.noSql.upsertEntry(this._rowToEntry(row, pkValues))
+        } catch (e: any) {
+            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 })
+        }
+    }
+
+    private async _doPost(result: OINOApiResult, rows: OINODataRow[], pkOverride?: string[]): Promise<void> {
+        // Validate all rows first and collect valid entries
+        const entries: OINONoSqlEntry[] = []
+        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: any) {
+            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 })
+        }
+    }
+
+    private async _doDelete(result: OINOApiResult, pkValues: string[]): Promise<void> {
+        try {
+            await this.noSql.deleteEntry(pkValues)
+        } catch (e: any) {
+            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: OINOApiRequest): Promise<OINOApiResult> {
+        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: OINODataRow[] = []
+
+        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: OINODataField) => 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: OINODataField) => 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: string[] | undefined
+                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: OINODataField) => 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: OINODataField) => 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: string, rowId: string, rowData: OINOApiData, queryParams?: OINOQueryParams): Promise<OINOApiResult> {
+        return this.doBatchApiRequest(new OINOApiRequest({ method, rowId, rowData, queryParams }))
+    }
+
+    async doBatchApiRequest(request: OINOApiRequest): Promise<OINOApiResult> {
+        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: OINONoSqlEntry[] = []
+            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: any) {
+                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: any) {
+                    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: OINOHttpRequest,
+        rowId: string,
+        rowData: OINOApiData,
+        queryParams: OINOQueryParams
+    ): Promise<OINOApiResult> {
+        const api_request = OINOApiRequest.fromHttpRequest(request, rowId, rowData, queryParams)
+        return this.doApiRequest(api_request)
+    }
+
+    async doRequest(
+        method: string,
+        rowId: string,
+        rowData: OINOApiData,
+        queryParams: OINOQueryParams,
+        contentType: OINOContentType = OINOContentType.json
+    ): Promise<OINOApiResult> {
+        return this.doApiRequest(new OINOApiRequest({
+            method,
+            rowId,
+            rowData,
+            queryParams,
+            requestType: contentType
+        }))
+    }
+}

package/src/OINONoSqlConstants.ts

@@ -0,0 +1,43 @@
+/*
+ * 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 type { OINONoSql } from "./OINONoSql.js"
+
+/**
+ * NoSQL class (constructor) type
+ * @param params nosql parameters
+ */
+export type OINONoSqlConstructor = new (params: OINONoSqlParams) => OINONoSql
+
+/** NoSQL storage connection parameters */
+export type OINONoSqlParams = {
+    /** Name of the nosql class (e.g. OINONoSqlAzureTable) */
+    type: string
+    /** Service endpoint URL */
+    url: string
+    /** Table name */
+    table: string
+    /** Provider-specific connection string (e.g. Azure Storage connection string) */
+    connectionStr?: string
+    /**
+     * Optional static partition key.  When set, all read/write operations are
+     * automatically scoped to this partition key, allowing multiple logical
+     * tables to share a single Azure Table Storage table.
+     */
+    staticPartitionKey?: string
+}
+
+/** A single NoSQL entity entry */
+export type OINONoSqlEntry = {
+    /** Primary key values in the order defined by the implementation's data model */
+    primaryKey: string[]
+    /** Last modification timestamp */
+    timestamp: Date
+    /** Entity tag */
+    etag: string
+    /** All custom entity properties as a key-value map */
+    properties: Record<string, unknown>
+}

package/src/OINONoSqlDataModel.ts

@@ -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,
+    OINODataRow,
+} from "@oino-ts/common"
+import { OINONoSqlApi } from "./OINONoSqlApi.js"
+import { OINONoSqlEntry } from "./OINONoSqlConstants.js"
+
+/**
+ * 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 */
+    readonly noSqlApi: OINONoSqlApi
+
+    /**
+     * Constructor.  Fields are added externally by the nosql implementation
+     * via `initializeApiDatamodel`.
+     *
+     * @param api the `OINONoSqlApi` that owns this data model
+     */
+    constructor(api: OINONoSqlApi) {
+        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: OINONoSqlEntry[]): OINOMemoryDataset {
+        const pk_fields = this.fields.filter(f => f.fieldParams.isPrimaryKey)
+        const rows: OINODataRow[] = entries.map(e => {
+            const row: OINODataRow = []
+            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/src/OINONoSqlFactory.ts

@@ -0,0 +1,79 @@
+/*
+ * 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 { OINOApiParams } from "@oino-ts/common"
+import { OINONoSqlParams, OINONoSqlConstructor } from "./OINONoSqlConstants.js"
+import { OINONoSql } from "./OINONoSql.js"
+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 {
+    private static _registry: Record<string, OINONoSqlConstructor> = {}
+
+    /**
+     * 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: string, noSqlClass: OINONoSqlConstructor): void {
+        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: OINONoSqlParams,
+        connect: boolean = true,
+        validate: boolean = true
+    ): Promise<OINONoSql> {
+        const no_sql_class = this._registry[params.type]
+        if (!no_sql_class) {
+            throw new Error("Unsupported nosql type: " + params.type)
+        }
+        const nosql: OINONoSql = 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: OINONoSql, params: OINOApiParams): Promise<OINONoSqlApi> {
+        const api = new OINONoSqlApi(noSql, params)
+        await noSql.initializeApiDatamodel(api)
+        return api
+    }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { OINONoSql } from "./OINONoSql.js"
+export { OINONoSqlDataModel } from "./OINONoSqlDataModel.js"
+export { OINONoSqlFactory } from "./OINONoSqlFactory.js"
+export { OINONoSqlApi } from "./OINONoSqlApi.js"
+export { type OINONoSqlConstructor, type OINONoSqlParams, type OINONoSqlEntry } from "./OINONoSqlConstants.js"