@oino-ts/types 1.0.6 → 1.0.8

package/blob/src/OINOBlob.d.ts

@@ -22,6 +22,17 @@ export declare abstract class OINOBlob extends OINODataSource {
     printCellAsValue(cellValue: OINODataCell, _sqlType: string): string;
     printStringValue(s: string): string;
     parseValueAsCell(v: OINODataCell, nativeType: string): OINODataCell;
+    /**
+     * Sanitize a blob name by replacing characters that are illegal or unsafe
+     * on this storage backend with `_`.
+     *
+     * The base implementation strips ASCII control characters (U+0000–U+001F
+     * and U+007F).  Subclasses should override to apply additional
+     * platform-specific rules.
+     *
+     * @param name raw blob name (path within the container)
+     */
+    sanitizeName(name: string): string;
     /**
      * Test whether a blob entry matches an `OINOQueryFilter` predicate.
      * Used for in-memory (result) filtering when the storage backend cannot

package/blob-aws/src/OINOBlobAwsS3.d.ts

@@ -1,37 +1,14 @@
 import { OINOApi, OINOResult, OINOQueryFilter } from "@oino-ts/common";
 import { OINOBlob, OINOBlobParams, type OINOBlobEntry, type OINOBlobFetchResult } from "@oino-ts/blob";
-/**
- * AWS S3 (and S3-compatible) implementation of `OINOBlob`.
- *
- * Authenticates using static access key credentials supplied via a JSON-encoded
- * connection string.  Connection parameters map as:
- * - `params.url`           → optional custom endpoint, e.g. `https://s3.eu-west-1.amazonaws.com`
- *                            or a compatible service such as MinIO / Cloudflare R2
- * - `params.container`     → S3 bucket name
- * - `params.connectionStr` → JSON string: `{"region":"…","accessKeyId":"…","secretAccessKey":"…"}`
- *
- * Register and use via the factory:
- * ```ts
- * import { OINOBlobFactory } from "@oino-ts/blob"
- * import { OINOBlobAwsS3 }      from "@oino-ts/blob-aws"
- *
- * OINOBlobFactory.registerBlob("OINOBlobAwsS3", OINOBlobAwsS3)
- *
- * const blob = await OINOBlobFactory.createBlob({
- *     type:          "OINOBlobAwsS3",
- *     url:           "",                             // leave empty for default AWS endpoint
- *     container:     "my-bucket",
- *     connectionStr: JSON.stringify({
- *         region:          "us-east-1",
- *         accessKeyId:     process.env.AWS_ACCESS_KEY_ID,
- *         secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
- *     })
- * })
- * ```
- */
 export declare class OINOBlobAwsS3 extends OINOBlob {
     private _s3Client;
     constructor(params: OINOBlobParams);
+    /**
+     * Replace characters that are unsafe in S3 object key names
+     * (`\`, control characters, and shell/URL-special characters
+     * `{`, `}`, `[`, `]`, `^`, `` ` ``, `|`, `<`, `>`, `#`, `%`) with `_`.
+     */
+    sanitizeName(name: string): string;
     /**
      * Initialise the AWS SDK S3 client from the JSON-encoded `connectionStr`.
      * Does not perform any network call.

package/blob-azure/src/OINOBlobAzure.d.ts

@@ -1,34 +1,13 @@
 import { OINOApi, OINOResult, OINOQueryFilter } from "@oino-ts/common";
 import { OINOBlob, OINOBlobParams, type OINOBlobEntry, type OINOBlobFetchResult } from "@oino-ts/blob";
-/**
- * Azure Blob Storage implementation of `OINOBlob`.
- *
- * Authenticates using an Azure Storage connection string.  Connection parameters map as:
- * - `params.url`           → blob service endpoint, e.g. `https://<account>.blob.core.windows.net`
- * - `params.container`     → container name
- * - `params.connectionStr` → Azure Storage connection string (e.g. `DefaultEndpointsProtocol=https;AccountName=...`)
- *
- * Register and use via the factory:
- * ```ts
- * import { OINOBlobFactory } from "@oino-ts/blob"
- * import { OINOBlobAzure }   from "@oino-ts/blob-azure"
- *
- * OINOBlobFactory.registerBlob("OINOBlobAzure", OINOBlobAzure)
- *
- * const blob = await OINOBlobFactory.createBlob({
- *     type:          "OINOBlobAzure",
- *     container:     "my-container",
- *     credentials:   either connectionStr or url and clientId
- * })
- * const api = await OINOBlobFactory.createApi(blob, {
- *     apiName:   "files",
- *     tableName: "uploads/"   // blob prefix / folder
- * })
- * ```
- */
 export declare class OINOBlobAzure extends OINOBlob {
     private _containerClient;
     constructor(params: OINOBlobParams);
+    /**
+     * Replace characters that Azure Blob Storage does not permit in blob names
+     * (`\` and ASCII control characters) with `_`.
+     */
+    sanitizeName(name: string): string;
     /**
      * Initialise the Azure SDK client.  Does not perform any network call.
      */

package/nosql-azure/src/OINONoSqlAzureTable.d.ts

@@ -4,12 +4,15 @@ import { type OINONoSqlEntry } from "@oino-ts/nosql";
 /**
  * Azure Table Storage implementation of `OINONoSql`.
  *
- * Authenticates using an Azure Storage connection string.  Connection parameters map as:
- * - `params.url`           → table service endpoint, e.g. `https://<account>.table.core.windows.net`
- * - `params.table`         → table name
- * - `params.connectionStr` → Azure Storage connection string (e.g. `DefaultEndpointsProtocol=https;AccountName=...`)
+ * Authenticates using either an Azure Storage connection string or a table
+ * service endpoint URL combined with a managed identity client id.  Connection
+ * parameters map as:
+ * - `credentials.url`           → table service endpoint, e.g. `https://<account>.table.core.windows.net`
+ * - `credentials.connectionStr` → Azure Storage connection string (e.g. `DefaultEndpointsProtocol=https;AccountName=...`)
+ * - `credentials.clientId`      → (optional) managed identity client id used with `credentials.url`
+ * - `params.table`             → table name
  *
- * Register and use via the factory:
+ * Register and use via the factory with a connection string:
  * ```ts
  * import { OINONoSqlFactory } from "@oino-ts/nosql"
  * import { OINONoSqlAzureTable } from "@oino-ts/nosql-azure"
@@ -17,10 +20,9 @@ import { type OINONoSqlEntry } from "@oino-ts/nosql";
  * OINONoSqlFactory.registerNoSql("OINONoSqlAzureTable", OINONoSqlAzureTable)
  *
  * const nosql = await OINONoSqlFactory.createNoSql({
- *     type:          "OINONoSqlAzureTable",
- *     url:           "https://myaccount.table.core.windows.net",
- *     table:         "myTable",
- *     connectionStr: process.env.AZURE_STORAGE_CONNECTION_STRING
+ *     type:        "OINONoSqlAzureTable",
+ *     table:       "myTable",
+ *     credentials: { connectionStr: process.env.AZURE_STORAGE_CONNECTION_STRING }
  * })
  * const api = await OINONoSqlFactory.createApi(nosql, {
  *     apiName:   "entities",
@@ -28,6 +30,18 @@ import { type OINONoSqlEntry } from "@oino-ts/nosql";
  * })
  * ```
  *
+ * Or with a service endpoint URL and a managed identity client id:
+ * ```ts
+ * const nosql = await OINONoSqlFactory.createNoSql({
+ *     type:        "OINONoSqlAzureTable",
+ *     table:       "myTable",
+ *     credentials: {
+ *         url:      "https://myaccount.table.core.windows.net",
+ *         clientId: process.env.AZURE_MANAGED_IDENTITY_CLIENT_ID
+ *     }
+ * })
+ * ```
+ *
  * ## Static partition key
  *
  * Set `staticPartitionKey` in the params to scope all operations to a fixed
@@ -128,4 +142,21 @@ export declare class OINONoSqlAzureTable extends OINONoSql {
      * @param entity raw entity from the Azure SDK
      */
     private static entityToEntry;
+    /**
+     * Encode an entry's `properties` into a flat map storable in Azure Table
+     * Storage.  Nested objects/arrays are JSON-stringified with a marker
+     * prefix (Azure Table Storage stores only primitive property values), and
+     * if the serialized properties exceed the 32k per-property limit the whole
+     * map is JSON-serialized and split across numbered `chunkN` properties.
+     *
+     * @param properties entry properties to encode
+     */
+    private static encodeProperties;
+    /**
+     * Decode stored Azure Table Storage properties back into the original
+     * `properties` map, reversing `encodeProperties`.
+     *
+     * @param properties stored properties to decode
+     */
+    private static decodeProperties;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oino-ts/types",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "OINO TS package for types.",
   "author": "Matias Kiviniemi (pragmatta)",
   "license": "MPL-2.0",