@boostercloud/framework-provider-azure 3.4.4-debug.2 → 4.0.0

package/dist/helpers/query-helper.js

@@ -36,14 +36,6 @@ async function search(cosmosDb, config, containerName, filters, limit, afterCurs
         // - Legacy cursors: Numeric cursor.id values must use OFFSET/LIMIT for backward compatibility
         const canUseContinuationToken = !isDistinctQuery;
         const hasLegacyCursor = typeof (afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.id) === 'string' && /^\d+$/.test(afterCursor.id);
-        logger.debug('PAGINATION DEBUG - Initial analysis:', {
-            isDistinctQuery,
-            canUseContinuationToken,
-            hasLegacyCursor,
-            afterCursor,
-            limit,
-            finalQuery,
-        });
         // Use Cosmos DB's continuation token pagination
         const feedOptions = {};
         if (limit) {
@@ -52,10 +44,6 @@ async function search(cosmosDb, config, containerName, filters, limit, afterCurs
         // Extract continuation token from the cursor (backward compatibility)
         if (afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.continuationToken) {
             feedOptions.continuationToken = afterCursor.continuationToken;
-            logger.debug('PAGINATION DEBUG - Using provided continuation token:', {
-                continuationToken: afterCursor.continuationToken,
-                feedOptions,
-            });
         }
         else if (!canUseContinuationToken || hasLegacyCursor) {
             // Legacy cursor format - fallback to OFFSET for backward compatibility
@@ -65,19 +53,8 @@ async function search(cosmosDb, config, containerName, filters, limit, afterCurs
                 legacyQuery += ` LIMIT ${limit} `;
             }
             const legacyQuerySpec = { ...querySpec, query: legacyQuery };
-            logger.debug('PAGINATION DEBUG - Using LEGACY OFFSET/LIMIT approach:', {
-                reason: !canUseContinuationToken ? 'DISTINCT query detected' : 'Legacy numeric cursor detected',
-                offset,
-                legacyQuery,
-                legacyQuerySpec,
-            });
             const { resources } = await container.items.query(legacyQuerySpec).fetchAll();
             const processedResources = processResources(resources);
-            logger.debug('PAGINATION DEBUG - Legacy query results:', {
-                resourcesCount: (resources === null || resources === void 0 ? void 0 : resources.length) || 0,
-                processedResourcesCount: processedResources.length,
-                nextCursor: { id: (offset + processedResources.length).toString() },
-            });
             return {
                 items: processedResources !== null && processedResources !== void 0 ? processedResources : [],
                 count: processedResources.length,
@@ -86,35 +63,17 @@ async function search(cosmosDb, config, containerName, filters, limit, afterCurs
                 },
             };
         }
-        logger.debug('PAGINATION DEBUG - About to execute continuation token query with feedOptions:', feedOptions);
         const queryIterator = container.items.query(querySpec, feedOptions);
         const { resources, continuationToken } = await queryIterator.fetchNext();
-        logger.debug('PAGINATION DEBUG - Cosmos SDK response:', {
-            resourcesCount: (resources === null || resources === void 0 ? void 0 : resources.length) || 0,
-            continuationTokenReceived: !!continuationToken,
-            continuationTokenValue: continuationToken,
-            continuationTokenType: typeof continuationToken,
-            continuationTokenLength: continuationToken === null || continuationToken === void 0 ? void 0 : continuationToken.length,
-        });
         const finalResources = processResources(resources || []);
         let cursor;
         if (continuationToken) {
             cursor = { continuationToken };
-            logger.debug('PAGINATION DEBUG - Setting cursor with continuation token:', cursor);
         }
         else if (finalResources.length > 0) {
             const currentOffset = (afterCursor === null || afterCursor === void 0 ? void 0 : afterCursor.id) && !isNaN(parseInt(afterCursor.id)) ? parseInt(afterCursor.id) : 0;
-            cursor = { id: (currentOffset + finalResources.length).toString() };
-            logger.debug('PAGINATION DEBUG - No continuation token, setting fallback cursor:', cursor);
+            cursor = { id: (currentOffset + finalResources.length).toString() }; // Use the length of the results to calculate the next id
         }
-        else {
-            logger.debug('PAGINATION DEBUG - No continuation token and no resources, no cursor set');
-        }
-        logger.debug('PAGINATION DEBUG - Final response:', {
-            itemsCount: finalResources.length,
-            cursor,
-            hasMoreResults: !!continuationToken,
-        });
         return {
             items: finalResources,
             count: finalResources.length,

package/dist/index.d.ts

@@ -2,3 +2,4 @@ import { HasInfrastructure, ProviderLibrary, RocketDescriptor } from '@boostercl
 export declare function loadInfrastructurePackage(packageName: string): HasInfrastructure;
 export declare const Provider: (rockets?: RocketDescriptor[]) => ProviderLibrary;
 export * from './constants';
+export * from './types/azure-func-types';

package/dist/index.js

@@ -166,3 +166,4 @@ const Provider = (rockets) => ({
 });
 exports.Provider = Provider;
 tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./types/azure-func-types"), exports);

package/dist/library/api-adapter.d.ts

@@ -1,14 +1,23 @@
-import { Cookie } from '@azure/functions';
+import { HttpResponseInit } from '@azure/functions';
 /**
- * See https://docs.microsoft.com/es-es/azure/azure-functions/functions-reference-node#response-object
+ * Standard HTTP response type for Azure Functions v4.
+ * Uses HttpResponseInit from '@azure/functions' v4.
  */
-export interface ContextResponse {
-    body: string;
-    headers: object;
-    isRaw?: boolean;
-    status: number;
-    cookies?: Cookie[];
+export type AzureHttpResponse = HttpResponseInit;
+/**
+ * Web PubSub response types for Azure Functions v4.
+ * These are returned directly from Web PubSub triggered functions.
+ */
+export interface WebPubSubConnectResponse {
+    subprotocol?: string;
+    userId?: string;
+    groups?: string[];
+    roles?: string[];
+}
+export interface WebPubSubMessageResponse {
+    data?: unknown;
+    dataType?: 'json' | 'text' | 'binary';
 }
-export declare function requestSucceeded(body?: unknown, headers?: Record<string, number | string | ReadonlyArray<string>>): Promise<ContextResponse | void>;
-export declare function requestFailed(error: Error): Promise<ContextResponse>;
-export declare function healthRequestResult(body: unknown, isHealthy: boolean): Promise<ContextResponse>;
+export declare function requestSucceeded(body?: unknown, headers?: Record<string, number | string | ReadonlyArray<string>>): Promise<AzureHttpResponse | WebPubSubConnectResponse | WebPubSubMessageResponse | void>;
+export declare function requestFailed(error: Error): Promise<AzureHttpResponse>;
+export declare function healthRequestResult(body: unknown, isHealthy: boolean): Promise<AzureHttpResponse>;

package/dist/library/api-adapter.js

@@ -5,25 +5,51 @@ exports.requestFailed = requestFailed;
 exports.healthRequestResult = healthRequestResult;
 const framework_types_1 = require("@boostercloud/framework-types");
 const WEB_SOCKET_PROTOCOL_HEADER = 'Sec-WebSocket-Protocol';
+const WEB_SOCKET_MESSAGE_MARKER_HEADER = 'X-Booster-WebSocket-Message';
 async function requestSucceeded(body, headers) {
+    // Check if this is a Web Pubsub CONNECT event (has the specific WebSocket header)
+    const isWebSocketConnect = headers && Object.keys(headers).includes(WEB_SOCKET_PROTOCOL_HEADER);
+    // Web PubSub CONNECT event - return subprotocol response format
+    if (isWebSocketConnect) {
+        const subprotocol = headers[WEB_SOCKET_PROTOCOL_HEADER];
+        return {
+            subprotocol: Array.isArray(subprotocol) ? subprotocol[0] : String(subprotocol),
+        };
+    }
+    // Check if this is a Web Pubsub MESSAGE event (has the marker header from framework-core
+    const isWebSocketMessage = headers && headers[WEB_SOCKET_MESSAGE_MARKER_HEADER] === 'true';
+    // Web PubSub MESSAGE event - return data response format
+    if (isWebSocketMessage) {
+        return {
+            data: body,
+            dataType: 'json',
+        };
+    }
+    // No body and no meaningful headers - nothing to return (e.g., DISCONNECT)
     if (!body && (!headers || Object.keys(headers).length === 0)) {
         return;
     }
-    const isWebSocket = headers && Object.keys(headers).includes(WEB_SOCKET_PROTOCOL_HEADER);
-    let extraParams = {};
-    if (isWebSocket) {
-        extraParams = { Subprotocol: headers[WEB_SOCKET_PROTOCOL_HEADER] };
+    // Standard HTTP response for everything else
+    const responseHeaders = {
+        'Access-Control-Allow-Origin': '*',
+        'Content-Type': 'application/json',
+    };
+    if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+            // Don't include internal Booster headers in HTTP response
+            if (key.startsWith('X-Booster-'))
+                continue;
+            responseHeaders[key] = Array.isArray(value) ? value.join(',') : String(value);
+        }
     }
-    return {
-        headers: {
-            'Access-Control-Allow-Origin': '*',
-            'Content-Type': 'application/json',
-            ...headers,
-        },
+    const response = {
+        headers: responseHeaders,
         status: 200,
-        body: body ? JSON.stringify(body) : '',
-        ...extraParams,
     };
+    if (body) {
+        response.jsonBody = body;
+    }
+    return response;
 }
 async function requestFailed(error) {
     const status = (0, framework_types_1.httpStatusCodeFor)(error);
@@ -33,11 +59,11 @@ async function requestFailed(error) {
             'Content-Type': 'application/json',
         },
         status,
-        body: JSON.stringify({
+        jsonBody: {
             status,
             title: (0, framework_types_1.toClassTitle)(error),
             reason: error.message,
-        }),
+        },
     };
 }
 async function healthRequestResult(body, isHealthy) {
@@ -47,6 +73,6 @@ async function healthRequestResult(body, isHealthy) {
             'Content-Type': 'application/json',
         },
         status: isHealthy ? 200 : 503,
-        body: JSON.stringify(body),
+        jsonBody: body,
     };
 }

package/dist/library/events-adapter.d.ts

@@ -1,7 +1,6 @@
 import { CosmosClient } from '@azure/cosmos';
 import { BoosterConfig, EntitySnapshotEnvelope, EventEnvelope, NonPersistedEntitySnapshotEnvelope, UUID } from '@boostercloud/framework-types';
-import { Context } from '@azure/functions';
-export declare function rawEventsToEnvelopes(context: Context): Array<EventEnvelope>;
+export declare function rawEventsToEnvelopes(rawInput: unknown): Array<EventEnvelope>;
 export declare function readEntityEventsSince(cosmosDb: CosmosClient, config: BoosterConfig, entityTypeName: string, entityID: UUID, since?: string): Promise<Array<EventEnvelope>>;
 export declare function readEntityLatestSnapshot(cosmosDb: CosmosClient, config: BoosterConfig, entityTypeName: string, entityID: UUID): Promise<EntitySnapshotEnvelope | undefined>;
 export declare function storeSnapshot(cosmosDb: CosmosClient, snapshotEnvelope: NonPersistedEntitySnapshotEnvelope, config: BoosterConfig): Promise<EntitySnapshotEnvelope>;

package/dist/library/events-adapter.js

@@ -8,9 +8,17 @@ exports.storeDispatchedEvent = storeDispatchedEvent;
 const framework_common_helpers_1 = require("@boostercloud/framework-common-helpers");
 const constants_1 = require("../constants");
 const partition_keys_1 = require("./partition-keys");
+const azure_func_types_1 = require("../types/azure-func-types");
 const originOfTime = new Date(0).toISOString();
-function rawEventsToEnvelopes(context) {
-    return context.bindings.rawEvent;
+function rawEventsToEnvelopes(rawInput) {
+    if ((0, azure_func_types_1.isCosmosDBFunctionInput)(rawInput)) {
+        return rawInput.documents;
+    }
+    // Fallback for direct array input (used in some test scenarios)
+    if (Array.isArray(rawInput)) {
+        return rawInput;
+    }
+    throw new Error('Invalid input type for rawEventsToEnvelopes: expected AzureCosmosDBFunctionInput or Array');
 }
 async function readEntityEventsSince(cosmosDb, config, entityTypeName, entityID, since) {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'events-adapter#readEntityEventsSince');

package/dist/library/events-stream-consumer-adapter.d.ts

@@ -1,5 +1,34 @@
 import { BoosterConfig, EventEnvelope, EventStream } from '@boostercloud/framework-types';
-import { Context } from '@azure/functions';
 import { CosmosClient } from '@azure/cosmos';
-export declare function dedupEventStream(cosmosDb: CosmosClient, config: BoosterConfig, context: Context): Promise<EventStream>;
-export declare function rawEventsStreamToEnvelopes(config: BoosterConfig, context: Context, dedupEventStream: EventStream): Array<EventEnvelope>;
+import { AzureEventHubFunctionInput } from '../types/azure-func-types';
+/**
+ * V4 Programming Model: Input wrapper for Event Hub consumer functions.
+ * Extends the base type with binding data for event metadata.
+ */
+export interface EventHubConsumerInput extends AzureEventHubFunctionInput {
+    /** Binding data containing Event Hub metadata arrays */
+    bindingData: {
+        partitionKeyArray: string[];
+        offsetArray: string[];
+        sequenceNumberArray: number[];
+        enqueuedTimeUtcArray: string[];
+    };
+}
+/**
+ * Deduplicates events from the Event Hub stream using Cosmos DB.
+ * In v4 programming model, messages are passed in the input wrapper.
+ * @param cosmosDb - The Cosmos DB client
+ * @param config - The Booster configuration
+ * @param rawInput - The raw input from the Azure Function, expected to be of type EventHubConsumerInput
+ * @returns A promise that resolves to the deduplicated event stream
+ */
+export declare function dedupEventStream(cosmosDb: CosmosClient, config: BoosterConfig, rawInput: unknown): Promise<EventStream>;
+/**
+ * Converts raw Event Hub events to Booster EventEnvelope format.
+ * In v4 programming model, binding data is passed via triggerMetadata on the context.
+ * @param config - Booster configuration
+ * @param rawInput - The raw input from the Azure Function
+ * @param dedupEventStream - The deduplicated event stream
+ * @returns An array of EventEnvelope objects
+ */
+export declare function rawEventsStreamToEnvelopes(config: BoosterConfig, rawInput: unknown, dedupEventStream: EventStream): Array<EventEnvelope>;

package/dist/library/events-stream-consumer-adapter.js

@@ -4,15 +4,32 @@ exports.dedupEventStream = dedupEventStream;
 exports.rawEventsStreamToEnvelopes = rawEventsStreamToEnvelopes;
 const framework_common_helpers_1 = require("@boostercloud/framework-common-helpers");
 const constants_1 = require("../constants");
+const azure_func_types_1 = require("../types/azure-func-types");
 const DEFAULT_DEDUP_TTL = 86400;
-async function dedupEventStream(cosmosDb, config, context) {
+/**
+ * Deduplicates events from the Event Hub stream using Cosmos DB.
+ * In v4 programming model, messages are passed in the input wrapper.
+ * @param cosmosDb - The Cosmos DB client
+ * @param config - The Booster configuration
+ * @param rawInput - The raw input from the Azure Function, expected to be of type EventHubConsumerInput
+ * @returns A promise that resolves to the deduplicated event stream
+ */
+async function dedupEventStream(cosmosDb, config, rawInput) {
     var _a, _b;
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'dedup-events-stream#dedupEventsStream');
-    const events = context.bindings.eventHubMessages || [];
+    let events = [];
+    if ((0, azure_func_types_1.isEventHubFunctionInput)(rawInput)) {
+        events = rawInput.messages;
+    }
+    else if (Array.isArray(rawInput)) {
+        // Direct array for testing
+        events = rawInput;
+    }
     logger.debug(`Dedup ${events.length} events`);
     const resources = [];
     for (const event of events) {
-        const rawParsed = JSON.parse(event);
+        // In v4, Event Hub messages may already be parsed objects, not JSON strings
+        const rawParsed = typeof event === 'string' ? JSON.parse(event) : event;
         const eventTag = {
             primaryKey: rawParsed._etag,
             createdAt: new Date().toISOString(),
@@ -31,23 +48,49 @@ async function dedupEventStream(cosmosDb, config, context) {
             if (error.code !== constants_1.AZURE_CONFLICT_ERROR_CODE) {
                 throw error;
             }
-            logger.warn(`Ignoring duplicated event with etag ${eventTag}.`);
+            logger.warn(`Ignoring duplicated event with etag ${eventTag.primaryKey}.`);
         }
     }
     return resources;
 }
-function rawEventsStreamToEnvelopes(config, context, dedupEventStream) {
+/**
+ * Converts raw Event Hub events to Booster EventEnvelope format.
+ * In v4 programming model, binding data is passed via triggerMetadata on the context.
+ * @param config - Booster configuration
+ * @param rawInput - The raw input from the Azure Function
+ * @param dedupEventStream - The deduplicated event stream
+ * @returns An array of EventEnvelope objects
+ */
+function rawEventsStreamToEnvelopes(config, rawInput, dedupEventStream) {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'events-adapter#rawEventsStreamToEnvelopes');
     logger.debug(`Mapping ${dedupEventStream.length} events`);
-    const bindingData = context.bindingData;
+    // Extract binding data from the input
+    let bindingData;
+    if (isEventHubConsumerInput(rawInput)) {
+        bindingData = rawInput.bindingData;
+    }
     return dedupEventStream.map((message, index) => {
-        const rawParsed = JSON.parse(message);
+        // In v4, Event Hub messages may already be parsed objects, not JSON strings
+        const rawParsed = typeof message === 'string' ? JSON.parse(message) : message;
         const instance = process.env.WEBSITE_INSTANCE_ID;
-        const partitionKeyArrayElement = bindingData.partitionKeyArray[index];
-        const offset = bindingData.offsetArray[index];
-        const sequence = bindingData.sequenceNumberArray[index];
-        const time = bindingData.enqueuedTimeUtcArray[index];
-        logger.debug(`CONSUMED_EVENT:${instance}#${partitionKeyArrayElement}=>(${index}#${offset}#${sequence}#${time})`);
+        if (bindingData) {
+            const partitionKeyArrayElement = bindingData.partitionKeyArray[index];
+            const offset = bindingData.offsetArray[index];
+            const sequence = bindingData.sequenceNumberArray[index];
+            const time = bindingData.enqueuedTimeUtcArray[index];
+            logger.debug(`CONSUMED_EVENT:${instance}#${partitionKeyArrayElement}=>(${index}#${offset}#${sequence}#${time})`);
+        }
         return rawParsed;
     });
 }
+/**
+ * Type guard to check if the input is an Event Hub consumer input with binding data
+ * @param input - The input to check
+ * @returns True if the input is an Event Hub consumer input, false otherwise
+ */
+function isEventHubConsumerInput(input) {
+    var _a;
+    return ((0, azure_func_types_1.isEventHubFunctionInput)(input) &&
+        typeof input.bindingData === 'object' &&
+        Array.isArray((_a = input.bindingData) === null || _a === void 0 ? void 0 : _a.partitionKeyArray));
+}

package/dist/library/graphql-adapter.d.ts

@@ -1,3 +1,2 @@
 import { BoosterConfig, GraphQLRequestEnvelope, GraphQLRequestEnvelopeError } from '@boostercloud/framework-types';
-import { Context } from '@azure/functions';
-export declare function rawGraphQLRequestToEnvelope(config: BoosterConfig, context: Context): Promise<GraphQLRequestEnvelope | GraphQLRequestEnvelopeError>;
+export declare function rawGraphQLRequestToEnvelope(config: BoosterConfig, rawRequest: unknown): Promise<GraphQLRequestEnvelope | GraphQLRequestEnvelopeError>;

package/dist/library/graphql-adapter.js

@@ -2,36 +2,157 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rawGraphQLRequestToEnvelope = rawGraphQLRequestToEnvelope;
 const framework_common_helpers_1 = require("@boostercloud/framework-common-helpers");
-async function rawGraphQLRequestToEnvelope(config, context) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+const azure_func_types_1 = require("../types/azure-func-types");
+async function rawGraphQLRequestToEnvelope(config, rawRequest) {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'graphql-adapter#rawGraphQLRequestToEnvelope');
-    logger.debug('Received GraphQL request: ', context.req);
-    const requestID = context.executionContext.invocationId;
-    const connectionContext = (_a = context.bindingData) === null || _a === void 0 ? void 0 : _a.connectionContext;
-    const connectionID = connectionContext === null || connectionContext === void 0 ? void 0 : connectionContext.connectionId;
-    const eventType = (connectionContext === null || connectionContext === void 0 ? void 0 : connectionContext.eventType) === undefined ? 'MESSAGE' : (_b = connectionContext === null || connectionContext === void 0 ? void 0 : connectionContext.eventName) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+    // Handle HTTP requests (v4 programming model)
+    if ((0, azure_func_types_1.isHttpFunctionInput)(rawRequest)) {
+        return handleHttpRequest(config, rawRequest, logger);
+    }
+    // Handle WebSocket requests (Web PubSub v4 programming model)
+    if ((0, azure_func_types_1.isWebPubSubFunctionInput)(rawRequest)) {
+        return handleWebPubSubRequest(config, rawRequest, logger);
+    }
+    // Fallback error for unknown input types
+    const error = new Error('Unknown request type received by GraphQL adapter');
+    logger.error('Received unknown request type:', rawRequest);
+    return {
+        error,
+        requestID: 'unknown',
+        eventType: 'MESSAGE',
+        context: {
+            request: {
+                headers: {},
+                body: undefined,
+            },
+            rawContext: rawRequest,
+        },
+    };
+}
+async function handleHttpRequest(config, input, logger) {
+    const { request, context } = input;
+    logger.debug('Received GraphQL request: ', request.url);
+    const requestID = context.invocationId;
     try {
+        // Parse the request body
         let graphQLValue = undefined;
-        if (((_c = context.bindings) === null || _c === void 0 ? void 0 : _c.data) || ((_d = context.req) === null || _d === void 0 ? void 0 : _d.body)) {
-            graphQLValue = ((_e = context.bindings) === null || _e === void 0 ? void 0 : _e.data) || ((_f = context.req) === null || _f === void 0 ? void 0 : _f.body);
+        try {
+            graphQLValue = await request.json();
+        }
+        catch {
+            // Body might not be JSON, try text
+            const textBody = await request.text();
+            if (textBody) {
+                try {
+                    graphQLValue = JSON.parse(textBody);
+                }
+                catch {
+                    graphQLValue = textBody;
+                }
+            }
+        }
+        // Convert headers to a plain object
+        const headers = {};
+        request.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            requestID,
+            eventType: 'MESSAGE',
+            token: request.headers.get('authorization') || undefined,
+            value: graphQLValue,
+            context: {
+                request: {
+                    headers,
+                    body: graphQLValue,
+                },
+                rawContext: input,
+            },
+        };
+    }
+    catch (e) {
+        const error = e;
+        logger.error('Error processing GraphQL HTTP request: ', error);
+        // Convert headers to a plain object for error response
+        const headers = {};
+        request.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            error,
+            requestID,
+            eventType: 'MESSAGE',
+            context: {
+                request: {
+                    headers,
+                    body: undefined,
+                },
+                rawContext: input,
+            },
+        };
+    }
+}
+async function handleWebPubSubRequest(config, input, logger) {
+    var _a, _b;
+    const { request: webPubSubRequest, context } = input;
+    const requestID = context.invocationId;
+    // Get connection context from either location (request or triggerMetadata)
+    const connectionContext = (0, azure_func_types_1.getWebPubSubConnectionContext)(input);
+    if (!connectionContext) {
+        const error = new Error('WebPubSub connectionContext not found in request or triggerMetadata');
+        logger.error('Missing connectionContext. Input structure', JSON.stringify(input, null, 2));
+        return {
+            error,
+            requestID,
+            eventType: 'MESSAGE',
+            context: {
+                request: {
+                    headers: {},
+                    body: undefined,
+                },
+                rawContext: input,
+            },
+        };
+    }
+    logger.debug('Received GraphQL WebSocket request: ', connectionContext.eventName);
+    const connectionID = connectionContext.connectionId;
+    // Map Web PubSub event names to Booster EventType
+    let eventType = 'MESSAGE';
+    if (((_a = connectionContext.eventType) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'system') {
+        const eventName = (_b = connectionContext.eventName) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+        if (eventName === 'CONNECT' || eventName === 'DISCONNECT') {
+            eventType = eventName;
+        }
+    }
+    try {
+        // Parse the data if it's a JSON string (Web PubSub sends data as string)
+        let messageData = webPubSubRequest === null || webPubSubRequest === void 0 ? void 0 : webPubSubRequest.data;
+        if (typeof messageData === 'string') {
+            try {
+                messageData = JSON.parse(messageData);
+                logger.debug('Parsed Web PubSub message data from string:', messageData);
+            }
+            catch {
+                logger.debug('WebPubSub data is not valid JSON, using as-is:', messageData);
+            }
         }
         return {
             requestID,
             connectionID,
             eventType,
-            token: (_h = (_g = context.req) === null || _g === void 0 ? void 0 : _g.headers) === null || _h === void 0 ? void 0 : _h.authorization,
-            value: graphQLValue,
+            value: messageData,
             context: {
                 request: {
-                    headers: (_j = context.req) === null || _j === void 0 ? void 0 : _j.headers,
-                    body: (_k = context.req) === null || _k === void 0 ? void 0 : _k.body,
+                    headers: {},
+                    body: messageData,
                 },
-                rawContext: context,
+                rawContext: input,
             },
         };
     }
     catch (e) {
         const error = e;
+        logger.error('Error processing GraphQL WebSocket request: ', error);
         return {
             error,
             requestID,
@@ -39,10 +160,10 @@ async function rawGraphQLRequestToEnvelope(config, context) {
             eventType,
             context: {
                 request: {
-                    headers: (_l = context.req) === null || _l === void 0 ? void 0 : _l.headers,
-                    body: (_m = context.req) === null || _m === void 0 ? void 0 : _m.body,
+                    headers: {},
+                    body: undefined,
                 },
-                rawContext: context,
+                rawContext: input,
             },
         };
     }

package/dist/library/health-adapter.d.ts

@@ -1,6 +1,5 @@
 import { BoosterConfig, HealthEnvelope } from '@boostercloud/framework-types';
 import { Container, CosmosClient } from '@azure/cosmos';
-import { Context } from '@azure/functions';
 export declare function databaseUrl(cosmosDb: CosmosClient, config: BoosterConfig): Promise<Array<string>>;
 export declare function getContainer(cosmosDb: CosmosClient, config: BoosterConfig, containerName: string): Container;
 export declare function isContainerUp(cosmosDb: CosmosClient, config: BoosterConfig, containerName: string): Promise<boolean>;
@@ -15,6 +14,13 @@ export declare function isRocketFunctionUp(rocketFunctionAppName: string): Promi
 export declare function areRocketFunctionsUp(): Promise<{
     [key: string]: boolean;
 }>;
-export declare function rawRequestToSensorHealthComponentPath(rawRequest: Context): string;
-export declare function rawRequestToSensorHealth(context: Context): HealthEnvelope;
+export declare function rawRequestToSensorHealthComponentPath(rawRequest: unknown): string;
+/**
+ * Converts the raw HTTP request to a HealthEnvelope.
+ * Note: Body is not parsed synchronously in v4 - it will be undefined.
+ * The health endpoint typically doesn't need the request body.
+ * @param rawRequest - The raw HTTP request from the Azure Function
+ * @returns A HealthEnvelope object
+ */
+export declare function rawRequestToSensorHealth(rawRequest: unknown): HealthEnvelope;
 export declare function databaseReadModelsHealthDetails(cosmosDb: CosmosClient, config: BoosterConfig): Promise<unknown>;

package/dist/library/health-adapter.js

@@ -17,6 +17,7 @@ exports.rawRequestToSensorHealth = rawRequestToSensorHealth;
 exports.databaseReadModelsHealthDetails = databaseReadModelsHealthDetails;
 const constants_1 = require("../constants");
 const framework_common_helpers_1 = require("@boostercloud/framework-common-helpers");
+const azure_func_types_1 = require("../types/azure-func-types");
 async function databaseUrl(cosmosDb, config) {
     const database = cosmosDb.database(config.resourceNames.applicationStack);
     return [database.url];
@@ -117,25 +118,46 @@ async function areRocketFunctionsUp() {
     return results.reduce((acc, result) => ({ ...acc, ...result }), {});
 }
 function rawRequestToSensorHealthComponentPath(rawRequest) {
-    var _a;
-    const parameters = (_a = rawRequest.req) === null || _a === void 0 ? void 0 : _a.url.replace(/^.*sensor\/health\/?/, '');
-    return parameters !== null && parameters !== void 0 ? parameters : '';
+    if ((0, azure_func_types_1.isHttpFunctionInput)(rawRequest)) {
+        const input = rawRequest;
+        const url = input.request.url;
+        const parameters = url.replace(/^.*sensor\/health\/?/, '');
+        return parameters !== null && parameters !== void 0 ? parameters : '';
+    }
+    return '';
 }
-function rawRequestToSensorHealth(context) {
-    var _a, _b, _c, _d;
-    const componentPath = rawRequestToSensorHealthComponentPath(context);
-    const requestID = context.executionContext.invocationId;
+/**
+ * Converts the raw HTTP request to a HealthEnvelope.
+ * Note: Body is not parsed synchronously in v4 - it will be undefined.
+ * The health endpoint typically doesn't need the request body.
+ * @param rawRequest - The raw HTTP request from the Azure Function
+ * @returns A HealthEnvelope object
+ */
+function rawRequestToSensorHealth(rawRequest) {
+    var _a;
+    if (!(0, azure_func_types_1.isHttpFunctionInput)(rawRequest)) {
+        throw new Error('Invalid input type for rawRequestToSensorHealth: expected AzureHttpFunctionInput');
+    }
+    const input = rawRequest;
+    const { request, context } = input;
+    const componentPath = rawRequestToSensorHealthComponentPath(rawRequest);
+    const requestID = context.invocationId;
+    // Convert headers to a plain object
+    const headers = {};
+    request.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
     return {
         requestID: requestID,
         context: {
             request: {
-                headers: (_a = context.req) === null || _a === void 0 ? void 0 : _a.headers,
-                body: (_b = context.req) === null || _b === void 0 ? void 0 : _b.body,
+                headers,
+                body: undefined, // Body not parsed synchronously in v4
             },
-            rawContext: context,
+            rawContext: rawRequest,
         },
         componentPath: componentPath,
-        token: (_d = (_c = context.req) === null || _c === void 0 ? void 0 : _c.headers) === null || _d === void 0 ? void 0 : _d.authorization,
+        token: (_a = request.headers.get('authorization')) !== null && _a !== void 0 ? _a : undefined,
     };
 }
 async function databaseReadModelsHealthDetails(cosmosDb, config) {

package/dist/library/read-model-adapter.d.ts

@@ -3,4 +3,11 @@ import { BoosterConfig, ReadModelEnvelope, ReadModelInterface, ReadOnlyNonEmptyA
 export declare function fetchReadModel(db: CosmosClient, config: BoosterConfig, readModelName: string, readModelID: UUID): Promise<ReadOnlyNonEmptyArray<ReadModelInterface>>;
 export declare function storeReadModel(db: CosmosClient, config: BoosterConfig, readModelName: string, readModel: ReadModelInterface): Promise<void>;
 export declare function deleteReadModel(db: CosmosClient, config: BoosterConfig, readModelName: string, readModel: ReadModelInterface): Promise<void>;
+/**
+ * Converts raw read model events from Cosmos DB change feed to Booster envelopes.
+ * In v4 programming model, the input wrapper contains documents directly and the typeName.
+ * @param config - Booster configuration
+ * @param rawEvents - Raw events from the Azure Function input
+ * @returns A promise that resolves to an array of ReadModelEnvelope objects
+ */
 export declare function rawReadModelEventsToEnvelopes(config: BoosterConfig, rawEvents: unknown): Promise<Array<ReadModelEnvelope>>;

package/dist/library/read-model-adapter.js

@@ -7,6 +7,7 @@ exports.rawReadModelEventsToEnvelopes = rawReadModelEventsToEnvelopes;
 const framework_types_1 = require("@boostercloud/framework-types");
 const framework_common_helpers_1 = require("@boostercloud/framework-common-helpers");
 const constants_1 = require("../constants");
+const subscription_model_1 = require("./subscription-model");
 async function fetchReadModel(db, config, readModelName, readModelID) {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'read-model-adapter#fetchReadModel');
     const { resource } = await db
@@ -100,12 +101,19 @@ async function deleteReadModel(db, config, readModelName, readModel) {
         logger.warn(`Read model to delete ${readModelName} ID = ${readModel.id} not found`);
     }
 }
+/**
+ * Converts raw read model events from Cosmos DB change feed to Booster envelopes.
+ * In v4 programming model, the input wrapper contains documents directly and the typeName.
+ * @param config - Booster configuration
+ * @param rawEvents - Raw events from the Azure Function input
+ * @returns A promise that resolves to an array of ReadModelEnvelope objects
+ */
 async function rawReadModelEventsToEnvelopes(config, rawEvents) {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'read-model-adapter#rawReadModelEventsToEnvelopes');
     logger.debug(`Parsing raw read models ${JSON.stringify(rawEvents)}`);
-    if (isSubscriptionContext(rawEvents)) {
-        const typeName = rawEvents.executionContext.functionName.replace('-subscriptions-notifier', '');
-        return rawEvents.bindings.rawEvent.map((rawEvent) => {
+    if ((0, subscription_model_1.isSubscriptionNotifierInput)(rawEvents)) {
+        const { documents, typeName } = rawEvents;
+        return documents.map((rawEvent) => {
             const { _rid, _self, _st, _etag, _lsn, _ts, ...rest } = rawEvent;
             return {
                 typeName: typeName,
@@ -116,7 +124,3 @@ async function rawReadModelEventsToEnvelopes(config, rawEvents) {
     logger.warn(`Unexpected events to be parsed ${JSON.stringify(rawEvents)}`);
     return [];
 }
-function isSubscriptionContext(rawRequest) {
-    return (rawRequest.bindings !== undefined &&
-        rawRequest.bindings.rawEvent !== undefined);
-}

package/dist/library/scheduled-adapter.d.ts

@@ -1,8 +1,24 @@
 import { BoosterConfig, ScheduledCommandEnvelope } from '@boostercloud/framework-types';
-interface AzureScheduledCommandEnvelope {
-    bindings: {
-        [name: string]: unknown;
-    };
+import { AzureTimerFunctionInput } from '../types/azure-func-types';
+/**
+ * V4 Programming Model: Input wrapper for scheduled command functions.
+ * Extends the base timer input with the command type name.
+ */
+export interface ScheduledCommandInput extends AzureTimerFunctionInput {
+    /** The scheduled command type name */
+    typeName: string;
 }
-export declare function rawScheduledInputToEnvelope(config: BoosterConfig, input: Partial<AzureScheduledCommandEnvelope>): Promise<ScheduledCommandEnvelope>;
-export {};
+/**
+ * Type guard to check if the input is a scheduled command input
+ * @param input - The input to check
+ * @returns True if the input is a ScheduledCommandInput, false otherwise
+ */
+export declare function isScheduledCommandInput(input: unknown): input is ScheduledCommandInput;
+/**
+ * Converts the raw timer trigger input to a Booster ScheduledCommandEnvelope.
+ * In v4 programming model, the timer info and typeName are passed in the input wrapper.
+ * @param config - Booster configuration
+ * @param input - The raw input from the Azure Function
+ * @returns A promise that resolves to a ScheduledCommandEnvelope
+ */
+export declare function rawScheduledInputToEnvelope(config: BoosterConfig, input: unknown): Promise<ScheduledCommandEnvelope>;

package/dist/library/scheduled-adapter.js

@@ -1,15 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScheduledCommandInput = isScheduledCommandInput;
 exports.rawScheduledInputToEnvelope = rawScheduledInputToEnvelope;
 const framework_types_1 = require("@boostercloud/framework-types");
 const framework_common_helpers_1 = require("@boostercloud/framework-common-helpers");
+const azure_func_types_1 = require("../types/azure-func-types");
+/**
+ * Type guard to check if the input is a scheduled command input
+ * @param input - The input to check
+ * @returns True if the input is a ScheduledCommandInput, false otherwise
+ */
+function isScheduledCommandInput(input) {
+    return (0, azure_func_types_1.isTimerFunctionInput)(input);
+}
+/**
+ * Converts the raw timer trigger input to a Booster ScheduledCommandEnvelope.
+ * In v4 programming model, the timer info and typeName are passed in the input wrapper.
+ * @param config - Booster configuration
+ * @param input - The raw input from the Azure Function
+ * @returns A promise that resolves to a ScheduledCommandEnvelope
+ */
 async function rawScheduledInputToEnvelope(config, input) {
     const logger = (0, framework_common_helpers_1.getLogger)(config, 'scheduled-adapter#rawScheduledInputToEnvelope');
     logger.debug('Received AzureScheduledCommand request: ', input);
-    if (!input.bindings || !Object.keys(input.bindings).length)
-        throw new Error(`bindings is not defined or empty, scheduled command envelope should have the structure {bindings: [name: string]: string }, but you gave ${JSON.stringify(input)}`);
+    if (!isScheduledCommandInput(input)) {
+        throw new Error(`Invalid scheduled command input. Expected ScheduledCommandInput with typeName and timer, but received: ${JSON.stringify(input)}`);
+    }
+    const { typeName, timer } = input;
+    logger.debug(`Processing scheduled command: ${typeName}, isPastDue: ${timer.isPastDue}`);
     return {
         requestID: framework_types_1.UUID.generate(),
-        typeName: Object.keys(input.bindings)[0],
+        typeName: typeName,
     };
 }

package/dist/library/subscription-model.d.ts

@@ -1,15 +1,8 @@
+import { InvocationContext } from '@azure/functions';
 import { BoosterMetadata } from '@boostercloud/framework-types';
-export interface SubscriptionContext {
-    invocationId: string;
-    traceContext: unknown;
-    executionContext: ExecutionContext;
-    bindings: Bindings;
-    bindingData: unknown;
-    bindingDefinitions: unknown;
-}
-export interface Bindings {
-    rawEvent: RawEvent[];
-}
+/**
+ * Raw event structure from Cosmos DB change feed
+ */
 export interface RawEvent {
     id: string;
     _rid: string;
@@ -20,9 +13,19 @@ export interface RawEvent {
     boosterMetadata: BoosterMetadata;
     _lsn: number;
 }
-export interface ExecutionContext {
-    invocationId: string;
-    functionName: string;
-    functionDirectory: string;
-    retryContext: null;
+/**
+ * V4 Programming Model: Input wrapper for subscription notifier functions.
+ * In v4, documents are passed directly as the first argument to the handler.
+ */
+export interface SubscriptionNotifierInput {
+    documents: RawEvent[];
+    context: InvocationContext;
+    /** The read model type name, extracted from function configuration */
+    typeName: string;
 }
+/**
+ * Type guard to check if the input is a v4 subscription notifier input
+ * @param input - The input to check
+ * @returns True if the input is a SubscriptionNotifierInput, false otherwise
+ */
+export declare function isSubscriptionNotifierInput(input: unknown): input is SubscriptionNotifierInput;

package/dist/library/subscription-model.js

@@ -1,2 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubscriptionNotifierInput = isSubscriptionNotifierInput;
+/**
+ * Type guard to check if the input is a v4 subscription notifier input
+ * @param input - The input to check
+ * @returns True if the input is a SubscriptionNotifierInput, false otherwise
+ */
+function isSubscriptionNotifierInput(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        'documents' in input &&
+        'context' in input &&
+        'typeName' in input &&
+        Array.isArray(input.documents));
+}

package/dist/types/azure-func-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Azure Functions v4 Programming Model Types
+ *
+ * These types provide a wrapper for Azure Functions vs inputs to standardize
+ * the interface between function handlers and Booster adapters
+ */
+import { HttpRequest, InvocationContext } from '@azure/functions';
+/**
+ * Standard wrapper for HTTP-triggered Azure Function v4 inputs.
+ * This replaces the v3 Context object for HTTP triggers.
+ */
+export interface AzureHttpFunctionInput {
+    request: HttpRequest;
+    context: InvocationContext;
+}
+/**
+ * Standard wrapper for CosmosDB-triggered Azure Function v4 inputs.
+ */
+export interface AzureCosmosDBFunctionInput {
+    documents: unknown[];
+    context: InvocationContext;
+}
+/**
+ * Standard wrapper for EventHub-triggered Azure Function v4 inputs.
+ */
+export interface AzureEventHubFunctionInput {
+    messages: unknown[];
+    context: InvocationContext;
+}
+/**
+ * Standard wrapper for Timer-triggered Azure Function v4 inputs.
+ */
+export interface AzureTimerFunctionInput {
+    timer: {
+        isPastDue: boolean;
+        schedule: {
+            adjustForDST: boolean;
+        };
+        scheduleStatus?: {
+            last: string;
+            next: string;
+            lastUpdated: string;
+        };
+    };
+    context: InvocationContext;
+}
+/**
+ * Web PubSub connection context structure
+ */
+export interface WebPubSubConnectionContext {
+    connectionId: string;
+    userId?: string;
+    hub: string;
+    eventType: string;
+    eventName: string;
+}
+/**
+ * Standard wrapper for Web PubSub-triggered Azure Function v4 inputs.
+ * Note: connectionContext can be found in either request.connectionContext
+ * or context.triggerMetadata.connectionContext depending on Azure Functions version.
+ */
+export interface AzureWebPubSubFunctionInput {
+    request: {
+        connectionContext?: WebPubSubConnectionContext;
+        data?: unknown;
+        dataType?: string;
+    };
+    context: InvocationContext & {
+        triggerMetadata?: {
+            connectionContext?: WebPubSubConnectionContext;
+        };
+    };
+}
+/**
+ * Type alias for the raw request that Booster adapters receive.
+ * This can be any of the v4 input types.
+ */
+export type AzureFunctionRawRequest = AzureHttpFunctionInput | AzureCosmosDBFunctionInput | AzureEventHubFunctionInput | AzureTimerFunctionInput | AzureWebPubSubFunctionInput;
+/**
+ * Type guard to check if the input is an HTTP function input
+ * @param input - The input to check
+ * @returns True if the input is an HTTP function input, false otherwise
+ */
+export declare function isHttpFunctionInput(input: unknown): input is AzureHttpFunctionInput;
+/**
+ * Type guard to check if the input is a CosmosDB function input
+ * @param input - The input to check
+ * @returns True if the input is a CosmosDB function input, false otherwise
+ */
+export declare function isCosmosDBFunctionInput(input: unknown): input is AzureCosmosDBFunctionInput;
+/**
+ * Type guard to check if the input is an EventHub function input
+ * @param input - The input to check
+ * @returns True if the input is an EventHub function input, false otherwise
+ */
+export declare function isEventHubFunctionInput(input: unknown): input is AzureEventHubFunctionInput;
+/**
+ * Type guard to check if the input is a Timer function input
+ * @param input - The input to check
+ * @returns True if the input is a Timer function input, false otherwise
+ */
+export declare function isTimerFunctionInput(input: unknown): input is AzureTimerFunctionInput;
+/**
+ * Type guard to check if the input is a Web PubSub function input.
+ * Checks for connectionContext in both request.connectionContext and context.triggerMetadata.connectionContext
+ * as Azure Functions v4 may provide it in different locations.
+ * @param input - The input to check
+ * @returns True if the input is a Web PubSub function input, false otherwise
+ */
+export declare function isWebPubSubFunctionInput(input: unknown): input is AzureWebPubSubFunctionInput;
+/**
+ * Helper to extract connectionContext from either location in Web PubSub input
+ * @param input - The Azure Web PubSub function input
+ * @returns The connection context if present, undefined otherwise
+ */
+export declare function getWebPubSubConnectionContext(input: AzureWebPubSubFunctionInput): WebPubSubConnectionContext | undefined;

package/dist/types/azure-func-types.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHttpFunctionInput = isHttpFunctionInput;
+exports.isCosmosDBFunctionInput = isCosmosDBFunctionInput;
+exports.isEventHubFunctionInput = isEventHubFunctionInput;
+exports.isTimerFunctionInput = isTimerFunctionInput;
+exports.isWebPubSubFunctionInput = isWebPubSubFunctionInput;
+exports.getWebPubSubConnectionContext = getWebPubSubConnectionContext;
+/**
+ * Type guard to check if the input is an HTTP function input
+ * @param input - The input to check
+ * @returns True if the input is an HTTP function input, false otherwise
+ */
+function isHttpFunctionInput(input) {
+    var _a;
+    return (typeof input === 'object' &&
+        input !== null &&
+        'request' in input &&
+        'context' in input &&
+        typeof ((_a = input.request) === null || _a === void 0 ? void 0 : _a.method) === 'string');
+}
+/**
+ * Type guard to check if the input is a CosmosDB function input
+ * @param input - The input to check
+ * @returns True if the input is a CosmosDB function input, false otherwise
+ */
+function isCosmosDBFunctionInput(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        'documents' in input &&
+        'context' in input &&
+        Array.isArray(input.documents));
+}
+/**
+ * Type guard to check if the input is an EventHub function input
+ * @param input - The input to check
+ * @returns True if the input is an EventHub function input, false otherwise
+ */
+function isEventHubFunctionInput(input) {
+    return (typeof input === 'object' &&
+        input !== null &&
+        'messages' in input &&
+        'context' in input &&
+        Array.isArray(input.messages));
+}
+/**
+ * Type guard to check if the input is a Timer function input
+ * @param input - The input to check
+ * @returns True if the input is a Timer function input, false otherwise
+ */
+function isTimerFunctionInput(input) {
+    var _a;
+    return (typeof input === 'object' &&
+        input !== null &&
+        'timer' in input &&
+        'context' in input &&
+        typeof ((_a = input.timer) === null || _a === void 0 ? void 0 : _a.isPastDue) === 'boolean');
+}
+/**
+ * Type guard to check if the input is a Web PubSub function input.
+ * Checks for connectionContext in both request.connectionContext and context.triggerMetadata.connectionContext
+ * as Azure Functions v4 may provide it in different locations.
+ * @param input - The input to check
+ * @returns True if the input is a Web PubSub function input, false otherwise
+ */
+function isWebPubSubFunctionInput(input) {
+    var _a, _b, _c, _d, _e;
+    if (typeof input !== 'object' || input === null || !('request' in input) || !('context' in input)) {
+        return false;
+    }
+    const typedInput = input;
+    // Check connectionContext in request.connectionContext
+    if (typeof ((_b = (_a = typedInput.request) === null || _a === void 0 ? void 0 : _a.connectionContext) === null || _b === void 0 ? void 0 : _b.connectionId) === 'string') {
+        return true;
+    }
+    // Check connectionContext in context.triggerMetadata.connectionContext
+    return typeof ((_e = (_d = (_c = typedInput.context) === null || _c === void 0 ? void 0 : _c.triggerMetadata) === null || _d === void 0 ? void 0 : _d.connectionContext) === null || _e === void 0 ? void 0 : _e.connectionId) === 'string';
+}
+/**
+ * Helper to extract connectionContext from either location in Web PubSub input
+ * @param input - The Azure Web PubSub function input
+ * @returns The connection context if present, undefined otherwise
+ */
+function getWebPubSubConnectionContext(input) {
+    var _a, _b, _c, _d;
+    return (_b = (_a = input.request) === null || _a === void 0 ? void 0 : _a.connectionContext) !== null && _b !== void 0 ? _b : (_d = (_c = input.context) === null || _c === void 0 ? void 0 : _c.triggerMetadata) === null || _d === void 0 ? void 0 : _d.connectionContext;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boostercloud/framework-provider-azure",
-  "version": "3.4.4-debug.2",
+  "version": "4.0.0",
   "description": "Handle Booster's integration with Azure",
   "keywords": [
     "framework-provider-azure"
@@ -20,21 +20,21 @@
     "url": "git+https://github.com/boostercloud/booster.git"
   },
   "engines": {
-    "node": ">=20.0.0 <21.0.0"
+    "node": ">=22.0.0 <23.0.0"
   },
   "dependencies": {
     "@azure/cosmos": "^4.3.0",
-    "@azure/functions": "^1.2.2",
+    "@azure/functions": "^4.0.0",
     "@azure/identity": "~4.7.0",
     "@azure/event-hubs": "5.11.1",
-    "@boostercloud/framework-common-helpers": "workspace:^3.4.3",
-    "@boostercloud/framework-types": "workspace:^3.4.3",
+    "@boostercloud/framework-common-helpers": "^4.0.0",
+    "@boostercloud/framework-types": "^4.0.0",
     "tslib": "^2.4.0",
     "@effect-ts/core": "^0.60.4",
     "@azure/web-pubsub": "~1.1.0"
   },
   "devDependencies": {
-    "@boostercloud/eslint-config": "workspace:^3.4.3",
+    "@boostercloud/eslint-config": "^4.0.0",
     "@types/chai": "4.2.18",
     "@types/chai-as-promised": "7.1.4",
     "@types/faker": "5.1.5",
@@ -61,27 +61,16 @@
     "typescript": "5.7.3",
     "eslint-plugin-unicorn": "~44.0.2"
   },
+  "bugs": {
+    "url": "https://github.com/boostercloud/booster/issues"
+  },
   "scripts": {
     "format": "prettier --write --ext '.js,.ts' **/*.ts **/*/*.ts",
     "lint:check": "eslint --ext '.js,.ts' **/*.ts",
     "lint:fix": "eslint --quiet --fix --ext '.js,.ts' **/*.ts",
     "build": "tsc -b tsconfig.json",
     "clean": "rimraf ./dist tsconfig.tsbuildinfo",
-    "prepack": "tsc -b tsconfig.json",
     "test:provider-azure": "npm run test",
     "test": "nyc --extension .ts mocha --forbid-only \"test/**/*.test.ts\""
-  },
-  "bugs": {
-    "url": "https://github.com/boostercloud/booster/issues"
-  },
-  "pnpm": {
-    "overrides": {
-      "pac-resolver@<5.0.0": ">=5.0.0",
-      "underscore@>=1.3.2 <1.12.1": ">=1.13.6",
-      "node-fetch@<2.6.7": ">=2.6.7",
-      "ws@>=7.0.0 <7.4.6": ">=7.4.6",
-      "nanoid@>=3.0.0 <3.1.31": ">=3.1.31",
-      "node-fetch@<2.6.1": ">=2.6.1"
-    }
   }
-}
+}