@vercube/storage 0.0.41 → 0.0.43

package/dist/Drivers/MemoryStorage.d.mts

@@ -1,4 +1,4 @@
-import { t as Storage } from "../Storage-CswGuxQf.mjs";
+import { t as Storage } from "../Storage-C6XPcRz-.mjs";
 
 //#region src/Drivers/MemoryStorage.d.ts
 /**

package/dist/Drivers/S3Storage.d.mts

@@ -1,4 +1,4 @@
-import { t as Storage } from "../Storage-CswGuxQf.mjs";
+import { t as Storage } from "../Storage-C6XPcRz-.mjs";
 import { Logger } from "@vercube/logger";
 import { S3ClientConfig } from "@aws-sdk/client-s3";
 

package/dist/Storage-C6XPcRz-.d.mts

@@ -0,0 +1,229 @@
+import { Container } from "@vercube/di";
+import "@vercube/logger";
+import "node:events";
+import "node:fs";
+import { Writable } from "node:stream";
+import "node:http";
+import "node:https";
+import "node:net";
+import "node:http2";
+
+//#region ../../node_modules/.pnpm/c12@3.3.3_magicast@0.5.1/node_modules/c12/dist/index.d.mts
+declare global {
+  var __c12_dotenv_vars__: Map<Record<string, any>, Set<string>>;
+} //#endregion
+//#region src/types.d.ts
+//#endregion
+//#region ../../node_modules/.pnpm/@types+aws-lambda@8.10.160/node_modules/@types/aws-lambda/handler.d.ts
+/**
+ * {@link Handler} context parameter.
+ * See {@link https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html AWS documentation}.
+ */
+interface Context {
+  callbackWaitsForEmptyEventLoop: boolean;
+  functionName: string;
+  functionVersion: string;
+  invokedFunctionArn: string;
+  memoryLimitInMB: string;
+  awsRequestId: string;
+  logGroupName: string;
+  logStreamName: string;
+  identity?: CognitoIdentity | undefined;
+  clientContext?: ClientContext | undefined;
+  tenantId?: string | undefined;
+  getRemainingTimeInMillis(): number; // Functions for compatibility with earlier Node.js Runtime v0.10.42
+  // No longer documented, so they are deprecated, but they still work
+  // as of the 12.x runtime, so they are not removed from the types.
+  /** @deprecated Use handler callback or promise result */
+  done(error?: Error, result?: any): void;
+  /** @deprecated Use handler callback with first argument or reject a promise result */
+  fail(error: Error | string): void;
+  /** @deprecated Use handler callback with second argument or resolve a promise result */
+  succeed(messageOrObject: any): void; // Unclear what behavior this is supposed to have, I couldn't find any still extant reference,
+  // and it behaves like the above, ignoring the object parameter.
+  /** @deprecated Use handler callback or promise result */
+  succeed(message: string, object: any): void;
+}
+interface CognitoIdentity {
+  cognitoIdentityId: string;
+  cognitoIdentityPoolId: string;
+}
+interface ClientContext {
+  client: ClientContextClient;
+  custom?: any;
+  env: ClientContextEnv;
+}
+interface ClientContextClient {
+  installationId: string;
+  appTitle: string;
+  appVersionName: string;
+  appVersionCode: string;
+  appPackageName: string;
+}
+interface ClientContextEnv {
+  platformVersion: string;
+  platform: string;
+  make: string;
+  model: string;
+  locale: string;
+}
+/**
+ * Interface for using response streaming from AWS Lambda.
+ * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+ *
+ * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+ * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+ *
+ * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+ * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+ *
+ * @example <caption>Writing to the response stream</caption>
+ * import 'aws-lambda';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *       responseStream.setContentType("text/plain");
+ *       responseStream.write("Hello, world!");
+ *       responseStream.end();
+ *   }
+ * );
+ *
+ * @example <caption>Using pipeline</caption>
+ * import 'aws-lambda';
+ * import { Readable } from 'stream';
+ * import { pipeline } from 'stream/promises';
+ * import zlib from 'zlib';
+ *
+ * export const handler = awslambda.streamifyResponse(
+ *   async (event, responseStream, context) => {
+ *     // As an example, convert event to a readable stream.
+ *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+ *
+ *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+ *   }
+ * );
+ */
+type StreamifyHandler<TEvent = any, TResult = any> = (event: TEvent, responseStream: awslambda.HttpResponseStream, context: Context) => TResult | Promise<TResult>;
+declare global {
+  namespace awslambda {
+    class HttpResponseStream extends Writable {
+      static from(writable: Writable, metadata: Record<string, unknown>): HttpResponseStream;
+      setContentType: (contentType: string) => void;
+    }
+    /**
+     * Decorator for using response streaming from AWS Lambda.
+     * To indicate to the runtime that Lambda should stream your function’s responses, you must wrap your function handler with the `awslambda.streamifyResponse()` decorator.
+     *
+     * The `streamifyResponse` decorator accepts the following additional parameter, `responseStream`, besides the default node handler parameters, `event`, and `context`.
+     * The new `responseStream` object provides a stream object that your function can write data to. Data written to this stream is sent immediately to the client. You can optionally set the Content-Type header of the response to pass additional metadata to your client about the contents of the stream.
+     *
+     * {@link https://aws.amazon.com/blogs/compute/introducing-aws-lambda-response-streaming/ AWS blog post}
+     * {@link https://docs.aws.amazon.com/lambda/latest/dg/config-rs-write-functions.html AWS documentation}
+     *
+     * @example <caption>Writing to the response stream</caption>
+     * import 'aws-lambda';
+     *
+     * export const handler = awslambda.streamifyResponse(
+     *   async (event, responseStream, context) => {
+     *       responseStream.setContentType("text/plain");
+     *       responseStream.write("Hello, world!");
+     *       responseStream.end();
+     *   }
+     * );
+     *
+     * @example <caption>Using pipeline</caption>
+     * import 'aws-lambda';
+     * import { Readable } from 'stream';
+     * import { pipeline } from 'stream/promises';
+     * import zlib from 'zlib';
+     *
+     * export const handler = awslambda.streamifyResponse(
+     *   async (event, responseStream, context) => {
+     *     // As an example, convert event to a readable stream.
+     *     const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
+     *
+     *     await pipeline(requestStream, zlib.createGzip(), responseStream);
+     *   }
+     * );
+     */
+    function streamifyResponse<TEvent = any, TResult = void>(handler: StreamifyHandler<TEvent, TResult>): StreamifyHandler<TEvent, TResult>;
+  }
+}
+//#endregion
+//#region ../core/src/Types/CommonTypes.d.ts
+type MaybePromise<T> = T | Promise<T>;
+//#endregion
+//#region src/Service/Storage.d.ts
+/**
+ * Abstract base class for storage implementations
+ * Provides a common interface for different storage providers
+ *
+ * @abstract
+ * @class Storage
+ * @description
+ * The Storage class defines a standard interface for storing and retrieving data.
+ * It supports basic operations like get, set, delete, and querying storage state.
+ * Concrete implementations must provide the actual storage mechanism.
+ */
+declare abstract class Storage<InitOptions = undefined> {
+  /**
+   * Initializes the storage implementation.
+   * Must be called before using any other storage operations.
+   *
+   * @param {InitOptions} options - Initialization parameters. May be omitted if not required by the storage implementation.
+   * @returns {Promise<void>} A promise that resolves when initialization is complete.
+   */
+  abstract initialize(options: InitOptions): void | Promise<void>;
+  /**
+   * Retrieves a value from storage by its key
+   * @template T - The type of the stored value
+   * @param {string} key - The key to retrieve the value for
+   * @returns {MaybePromise<T | null>} A promise that resolves with the stored value
+   */
+  abstract getItem<T = unknown>(key: string): MaybePromise<T | null>;
+  /**
+   * Retrieves multiple items from storage by their keys
+   * @template T - The type of the stored value
+   * @param {string[]} keys - The keys to retrieve the values for
+   * @returns {MaybePromise<T[]>} A promise that resolves with the stored values or empty array if not found
+   */
+  abstract getItems<T = unknown>(keys: string[]): MaybePromise<T[]>;
+  /**
+   * Stores a value in storage with the specified key
+   * @template T - The type of the value to store
+   * @template U - The type of the optional options object
+   * @param {string} key - The key under which to store the value
+   * @param {T} value - The value to store
+   * @returns {MaybePromise<void>} A promise that resolves when the value is stored
+   */
+  abstract setItem<T = unknown, U = unknown>(key: string, value: T, options?: U): MaybePromise<void>;
+  /**
+   * Removes a value from storage by its key
+   * @param {string} key - The key of the value to delete
+   * @returns {MaybePromise<void>} A promise that resolves when the value is deleted
+   */
+  abstract deleteItem(key: string): MaybePromise<void>;
+  /**
+   * Checks if a value exists in storage for the given key
+   * @param {string} key - The key to check
+   * @returns {MaybePromise<boolean>} A promise that resolves to true if the key exists, false otherwise
+   */
+  abstract hasItem(key: string): MaybePromise<boolean>;
+  /**
+   * Retrieves all keys currently stored in storage
+   * @returns {MaybePromise<string[]>} A promise that resolves with an array of all stored keys
+   */
+  abstract getKeys(): MaybePromise<string[]>;
+  /**
+   * Removes all stored values from storage
+   * @returns {Promise<void>} A promise that resolves when all values are cleared
+   */
+  abstract clear(): MaybePromise<void>;
+  /**
+   * Gets the number of key-value pairs stored in storage
+   * @returns {Promise<number>} A promise that resolves with the number of stored items
+   */
+  abstract size(): MaybePromise<number>;
+}
+//#endregion
+export { Storage as t };

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { t as Storage } from "./Storage-CswGuxQf.mjs";
+import { t as Storage } from "./Storage-C6XPcRz-.mjs";
 import { IOC } from "@vercube/di";
 
 //#region src/Types/StorageTypes.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/storage",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "Storage module for Vercube framework",
   "repository": {
     "type": "git",
@@ -24,11 +24,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@vercube/di": "0.0.41",
-    "@vercube/logger": "0.0.41"
+    "@vercube/di": "0.0.43",
+    "@vercube/logger": "0.0.43"
   },
   "optionalDependencies": {
-    "@aws-sdk/client-s3": "3.978.0"
+    "@aws-sdk/client-s3": "3.983.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/Storage-CswGuxQf.d.mts

@@ -1,93 +0,0 @@
-import { Container } from "@vercube/di";
-import "@vercube/logger";
-import "node:events";
-import "node:fs";
-import "node:stream";
-import "node:http";
-import "node:https";
-import "node:net";
-import "node:http2";
-
-//#region ../../node_modules/.pnpm/c12@3.3.3_magicast@0.5.1/node_modules/c12/dist/index.d.mts
-declare global {
-  var __c12_dotenv_vars__: Map<Record<string, any>, Set<string>>;
-} //#endregion
-//#region src/types.d.ts
-//#endregion
-//#region ../core/src/Types/CommonTypes.d.ts
-type MaybePromise<T> = T | Promise<T>;
-//#endregion
-//#region src/Service/Storage.d.ts
-/**
- * Abstract base class for storage implementations
- * Provides a common interface for different storage providers
- *
- * @abstract
- * @class Storage
- * @description
- * The Storage class defines a standard interface for storing and retrieving data.
- * It supports basic operations like get, set, delete, and querying storage state.
- * Concrete implementations must provide the actual storage mechanism.
- */
-declare abstract class Storage<InitOptions = undefined> {
-  /**
-   * Initializes the storage implementation.
-   * Must be called before using any other storage operations.
-   *
-   * @param {InitOptions} options - Initialization parameters. May be omitted if not required by the storage implementation.
-   * @returns {Promise<void>} A promise that resolves when initialization is complete.
-   */
-  abstract initialize(options: InitOptions): void | Promise<void>;
-  /**
-   * Retrieves a value from storage by its key
-   * @template T - The type of the stored value
-   * @param {string} key - The key to retrieve the value for
-   * @returns {MaybePromise<T | null>} A promise that resolves with the stored value
-   */
-  abstract getItem<T = unknown>(key: string): MaybePromise<T | null>;
-  /**
-   * Retrieves multiple items from storage by their keys
-   * @template T - The type of the stored value
-   * @param {string[]} keys - The keys to retrieve the values for
-   * @returns {MaybePromise<T[]>} A promise that resolves with the stored values or empty array if not found
-   */
-  abstract getItems<T = unknown>(keys: string[]): MaybePromise<T[]>;
-  /**
-   * Stores a value in storage with the specified key
-   * @template T - The type of the value to store
-   * @template U - The type of the optional options object
-   * @param {string} key - The key under which to store the value
-   * @param {T} value - The value to store
-   * @returns {MaybePromise<void>} A promise that resolves when the value is stored
-   */
-  abstract setItem<T = unknown, U = unknown>(key: string, value: T, options?: U): MaybePromise<void>;
-  /**
-   * Removes a value from storage by its key
-   * @param {string} key - The key of the value to delete
-   * @returns {MaybePromise<void>} A promise that resolves when the value is deleted
-   */
-  abstract deleteItem(key: string): MaybePromise<void>;
-  /**
-   * Checks if a value exists in storage for the given key
-   * @param {string} key - The key to check
-   * @returns {MaybePromise<boolean>} A promise that resolves to true if the key exists, false otherwise
-   */
-  abstract hasItem(key: string): MaybePromise<boolean>;
-  /**
-   * Retrieves all keys currently stored in storage
-   * @returns {MaybePromise<string[]>} A promise that resolves with an array of all stored keys
-   */
-  abstract getKeys(): MaybePromise<string[]>;
-  /**
-   * Removes all stored values from storage
-   * @returns {Promise<void>} A promise that resolves when all values are cleared
-   */
-  abstract clear(): MaybePromise<void>;
-  /**
-   * Gets the number of key-value pairs stored in storage
-   * @returns {Promise<number>} A promise that resolves with the number of stored items
-   */
-  abstract size(): MaybePromise<number>;
-}
-//#endregion
-export { Storage as t };