@markwharton/pwa-core 1.0.0

package/dist/auth/apiKey.d.ts

@@ -0,0 +1,24 @@
+/**
+ * API Key utilities for machine-to-machine authentication
+ */
+/**
+ * Extract API key from X-API-Key header
+ */
+export declare function extractApiKey(request: {
+    headers: {
+        get(name: string): string | null;
+    };
+}): string | null;
+/**
+ * Hash an API key for secure storage
+ * Store this hash, not the raw key
+ */
+export declare function hashApiKey(apiKey: string): string;
+/**
+ * Validate API key against stored hash
+ */
+export declare function validateApiKey(apiKey: string, storedHash: string): boolean;
+/**
+ * Generate a new API key (random 32-byte hex string)
+ */
+export declare function generateApiKey(): string;

package/dist/auth/apiKey.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractApiKey = extractApiKey;
+exports.hashApiKey = hashApiKey;
+exports.validateApiKey = validateApiKey;
+exports.generateApiKey = generateApiKey;
+const crypto_1 = require("crypto");
+/**
+ * API Key utilities for machine-to-machine authentication
+ */
+/**
+ * Extract API key from X-API-Key header
+ */
+function extractApiKey(request) {
+    return request.headers.get('X-API-Key');
+}
+/**
+ * Hash an API key for secure storage
+ * Store this hash, not the raw key
+ */
+function hashApiKey(apiKey) {
+    return (0, crypto_1.createHash)('sha256').update(apiKey).digest('hex');
+}
+/**
+ * Validate API key against stored hash
+ */
+function validateApiKey(apiKey, storedHash) {
+    const keyHash = hashApiKey(apiKey);
+    return keyHash === storedHash;
+}
+/**
+ * Generate a new API key (random 32-byte hex string)
+ */
+function generateApiKey() {
+    return (0, crypto_1.randomBytes)(32).toString('hex');
+}

package/dist/auth/index.d.ts

@@ -0,0 +1,3 @@
+export { type BaseJwtPayload, type UserTokenPayload, type UsernameTokenPayload, type RoleTokenPayload, hasUsername, hasRole, isAdmin } from './types';
+export { initAuth, getJwtSecret, extractToken, validateToken, generateToken, generateLongLivedToken } from './token';
+export { extractApiKey, hashApiKey, validateApiKey, generateApiKey } from './apiKey';

package/dist/auth/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApiKey = exports.validateApiKey = exports.hashApiKey = exports.extractApiKey = exports.generateLongLivedToken = exports.generateToken = exports.validateToken = exports.extractToken = exports.getJwtSecret = exports.initAuth = exports.isAdmin = exports.hasRole = exports.hasUsername = void 0;
+// Types and type guards
+var types_1 = require("./types");
+Object.defineProperty(exports, "hasUsername", { enumerable: true, get: function () { return types_1.hasUsername; } });
+Object.defineProperty(exports, "hasRole", { enumerable: true, get: function () { return types_1.hasRole; } });
+Object.defineProperty(exports, "isAdmin", { enumerable: true, get: function () { return types_1.isAdmin; } });
+// JWT functions
+var token_1 = require("./token");
+Object.defineProperty(exports, "initAuth", { enumerable: true, get: function () { return token_1.initAuth; } });
+Object.defineProperty(exports, "getJwtSecret", { enumerable: true, get: function () { return token_1.getJwtSecret; } });
+Object.defineProperty(exports, "extractToken", { enumerable: true, get: function () { return token_1.extractToken; } });
+Object.defineProperty(exports, "validateToken", { enumerable: true, get: function () { return token_1.validateToken; } });
+Object.defineProperty(exports, "generateToken", { enumerable: true, get: function () { return token_1.generateToken; } });
+Object.defineProperty(exports, "generateLongLivedToken", { enumerable: true, get: function () { return token_1.generateLongLivedToken; } });
+// API key functions
+var apiKey_1 = require("./apiKey");
+Object.defineProperty(exports, "extractApiKey", { enumerable: true, get: function () { return apiKey_1.extractApiKey; } });
+Object.defineProperty(exports, "hashApiKey", { enumerable: true, get: function () { return apiKey_1.hashApiKey; } });
+Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
+Object.defineProperty(exports, "generateApiKey", { enumerable: true, get: function () { return apiKey_1.generateApiKey; } });

package/dist/auth/token.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Initialize JWT secret - call once at startup
+ * Fails fast if secret is missing or too short
+ */
+export declare function initAuth(secret: string | undefined, minLength?: number): void;
+/**
+ * Get the JWT secret (throws if not initialized)
+ */
+export declare function getJwtSecret(): string;
+/**
+ * Extract Bearer token from Authorization header
+ */
+export declare function extractToken(authHeader: string | null): string | null;
+/**
+ * Validate and decode a JWT token
+ * Generic type allows project-specific payload shapes
+ */
+export declare function validateToken<T extends object>(token: string): T | null;
+/**
+ * Generate a JWT token with custom payload
+ */
+export declare function generateToken<T extends object>(payload: T, expiresIn?: string): string;
+/**
+ * Generate a long-lived token (e.g., for machine/API access)
+ */
+export declare function generateLongLivedToken<T extends object>(payload: T, expiresInDays?: number): string;

package/dist/auth/token.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAuth = initAuth;
+exports.getJwtSecret = getJwtSecret;
+exports.extractToken = extractToken;
+exports.validateToken = validateToken;
+exports.generateToken = generateToken;
+exports.generateLongLivedToken = generateLongLivedToken;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+/**
+ * JWT token utilities - works with any payload structure
+ * Use BaseJwtPayload or extend it for type safety
+ */
+let jwtSecret = null;
+/**
+ * Initialize JWT secret - call once at startup
+ * Fails fast if secret is missing or too short
+ */
+function initAuth(secret, minLength = 32) {
+    if (!secret || secret.length < minLength) {
+        throw new Error(`JWT_SECRET must be at least ${minLength} characters`);
+    }
+    jwtSecret = secret;
+}
+/**
+ * Get the JWT secret (throws if not initialized)
+ */
+function getJwtSecret() {
+    if (!jwtSecret) {
+        throw new Error('Auth not initialized. Call initAuth() first.');
+    }
+    return jwtSecret;
+}
+/**
+ * Extract Bearer token from Authorization header
+ */
+function extractToken(authHeader) {
+    if (!authHeader?.startsWith('Bearer ')) {
+        return null;
+    }
+    return authHeader.slice(7);
+}
+/**
+ * Validate and decode a JWT token
+ * Generic type allows project-specific payload shapes
+ */
+function validateToken(token) {
+    try {
+        const payload = jsonwebtoken_1.default.verify(token, getJwtSecret());
+        if (typeof payload === 'object' && payload !== null) {
+            return payload;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate a JWT token with custom payload
+ */
+function generateToken(payload, expiresIn = '7d') {
+    return jsonwebtoken_1.default.sign(payload, getJwtSecret(), { expiresIn });
+}
+/**
+ * Generate a long-lived token (e.g., for machine/API access)
+ */
+function generateLongLivedToken(payload, expiresInDays = 3650) {
+    return jsonwebtoken_1.default.sign(payload, getJwtSecret(), { expiresIn: `${expiresInDays}d` });
+}

package/dist/auth/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Base JWT payload - all tokens include these fields
+ * Projects extend this with their specific fields
+ */
+export interface BaseJwtPayload {
+    iat: number;
+    exp: number;
+}
+/**
+ * Standard user token payload
+ * Used by: azure-pwa-starter, azure-alert-service (admin), onsite-monitor
+ */
+export interface UserTokenPayload extends BaseJwtPayload {
+    authenticated: true;
+    tokenType: 'user' | 'machine';
+}
+/**
+ * Username-based token payload
+ * Used by: financial-tracker
+ */
+export interface UsernameTokenPayload extends BaseJwtPayload {
+    username: string;
+}
+/**
+ * Role-based token payload
+ * Used by: azure-alert-service
+ */
+export interface RoleTokenPayload extends BaseJwtPayload {
+    authenticated: true;
+    tokenType: 'user' | 'machine';
+    role: 'admin' | 'viewer';
+    viewerTokenId?: string;
+}
+/**
+ * Type guard to check if payload has a username
+ */
+export declare function hasUsername(payload: BaseJwtPayload): payload is UsernameTokenPayload;
+/**
+ * Type guard to check if payload has a role
+ */
+export declare function hasRole(payload: BaseJwtPayload): payload is RoleTokenPayload;
+/**
+ * Type guard to check if payload is admin
+ */
+export declare function isAdmin(payload: BaseJwtPayload): boolean;

package/dist/auth/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUsername = hasUsername;
+exports.hasRole = hasRole;
+exports.isAdmin = isAdmin;
+/**
+ * Type guard to check if payload has a username
+ */
+function hasUsername(payload) {
+    return 'username' in payload && typeof payload.username === 'string';
+}
+/**
+ * Type guard to check if payload has a role
+ */
+function hasRole(payload) {
+    return 'role' in payload;
+}
+/**
+ * Type guard to check if payload is admin
+ */
+function isAdmin(payload) {
+    return hasRole(payload) && payload.role === 'admin';
+}

package/dist/client/ApiError.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Custom error class for API errors
+ * Preserves status code and error message from server
+ */
+export declare class ApiError extends Error {
+    status: number;
+    details?: string | undefined;
+    constructor(status: number, message: string, details?: string | undefined);
+    /**
+     * Check if this is an authentication error
+     */
+    isUnauthorized(): boolean;
+    /**
+     * Check if this is a not found error
+     */
+    isNotFound(): boolean;
+    /**
+     * Check if this is a validation error
+     */
+    isBadRequest(): boolean;
+}

package/dist/client/ApiError.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+/**
+ * Custom error class for API errors
+ * Preserves status code and error message from server
+ */
+class ApiError extends Error {
+    constructor(status, message, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+        this.name = 'ApiError';
+    }
+    /**
+     * Check if this is an authentication error
+     */
+    isUnauthorized() {
+        return this.status === 401;
+    }
+    /**
+     * Check if this is a not found error
+     */
+    isNotFound() {
+        return this.status === 404;
+    }
+    /**
+     * Check if this is a validation error
+     */
+    isBadRequest() {
+        return this.status === 400;
+    }
+}
+exports.ApiError = ApiError;

package/dist/client/api.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Initialize the API client
+ */
+export declare function initApiClient(config: {
+    getToken: () => string | null;
+    onUnauthorized?: () => void;
+}): void;
+/**
+ * API response wrapper
+ */
+export interface ApiResponse<T> {
+    ok: boolean;
+    status: number;
+    data?: T;
+    error?: string;
+}
+/**
+ * Make an authenticated API call
+ */
+export declare function apiCall<T>(url: string, options?: RequestInit): Promise<T>;
+/**
+ * GET request helper
+ */
+export declare function apiGet<T>(url: string): Promise<T>;
+/**
+ * POST request helper
+ */
+export declare function apiPost<T>(url: string, body?: unknown): Promise<T>;
+/**
+ * PUT request helper
+ */
+export declare function apiPut<T>(url: string, body?: unknown): Promise<T>;
+/**
+ * PATCH request helper
+ */
+export declare function apiPatch<T>(url: string, body?: unknown): Promise<T>;
+/**
+ * DELETE request helper
+ */
+export declare function apiDelete<T>(url: string): Promise<T>;
+/**
+ * Alternative: Response wrapper style (like financial-tracker's authJsonFetch)
+ */
+export declare function apiCallSafe<T>(url: string, options?: RequestInit): Promise<ApiResponse<T>>;

package/dist/client/api.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initApiClient = initApiClient;
+exports.apiCall = apiCall;
+exports.apiGet = apiGet;
+exports.apiPost = apiPost;
+exports.apiPut = apiPut;
+exports.apiPatch = apiPatch;
+exports.apiDelete = apiDelete;
+exports.apiCallSafe = apiCallSafe;
+const ApiError_1 = require("./ApiError");
+/**
+ * Client-side API utilities for authenticated requests
+ */
+// Token getter function - set by consuming app
+let getToken = null;
+// Callback for 401 responses (e.g., redirect to login)
+let onUnauthorized = null;
+/**
+ * Initialize the API client
+ */
+function initApiClient(config) {
+    getToken = config.getToken;
+    onUnauthorized = config.onUnauthorized ?? null;
+}
+/**
+ * Make an authenticated API call
+ */
+async function apiCall(url, options = {}) {
+    const token = getToken?.();
+    const headers = {
+        'Content-Type': 'application/json',
+        ...options.headers
+    };
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    const response = await fetch(url, {
+        ...options,
+        headers
+    });
+    if (!response.ok) {
+        if (response.status === 401 && onUnauthorized) {
+            onUnauthorized();
+        }
+        let errorMessage = 'Request failed';
+        try {
+            const errorData = (await response.json());
+            errorMessage = errorData.error || errorMessage;
+        }
+        catch {
+            // Ignore JSON parse errors
+        }
+        throw new ApiError_1.ApiError(response.status, errorMessage);
+    }
+    // Handle empty responses
+    const text = await response.text();
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+/**
+ * GET request helper
+ */
+async function apiGet(url) {
+    return apiCall(url, { method: 'GET' });
+}
+/**
+ * POST request helper
+ */
+async function apiPost(url, body) {
+    return apiCall(url, {
+        method: 'POST',
+        body: body ? JSON.stringify(body) : undefined
+    });
+}
+/**
+ * PUT request helper
+ */
+async function apiPut(url, body) {
+    return apiCall(url, {
+        method: 'PUT',
+        body: body ? JSON.stringify(body) : undefined
+    });
+}
+/**
+ * PATCH request helper
+ */
+async function apiPatch(url, body) {
+    return apiCall(url, {
+        method: 'PATCH',
+        body: body ? JSON.stringify(body) : undefined
+    });
+}
+/**
+ * DELETE request helper
+ */
+async function apiDelete(url) {
+    return apiCall(url, { method: 'DELETE' });
+}
+/**
+ * Alternative: Response wrapper style (like financial-tracker's authJsonFetch)
+ */
+async function apiCallSafe(url, options = {}) {
+    try {
+        const data = await apiCall(url, options);
+        return { ok: true, status: 200, data };
+    }
+    catch (error) {
+        if (error instanceof ApiError_1.ApiError) {
+            return { ok: false, status: error.status, error: error.message };
+        }
+        return { ok: false, status: 0, error: 'Network error' };
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export { ApiError } from './ApiError';
+export { initApiClient, type ApiResponse, apiCall, apiGet, apiPost, apiPut, apiPatch, apiDelete, apiCallSafe } from './api';

package/dist/client/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiCallSafe = exports.apiDelete = exports.apiPatch = exports.apiPut = exports.apiPost = exports.apiGet = exports.apiCall = exports.initApiClient = exports.ApiError = void 0;
+var ApiError_1 = require("./ApiError");
+Object.defineProperty(exports, "ApiError", { enumerable: true, get: function () { return ApiError_1.ApiError; } });
+var api_1 = require("./api");
+Object.defineProperty(exports, "initApiClient", { enumerable: true, get: function () { return api_1.initApiClient; } });
+Object.defineProperty(exports, "apiCall", { enumerable: true, get: function () { return api_1.apiCall; } });
+Object.defineProperty(exports, "apiGet", { enumerable: true, get: function () { return api_1.apiGet; } });
+Object.defineProperty(exports, "apiPost", { enumerable: true, get: function () { return api_1.apiPost; } });
+Object.defineProperty(exports, "apiPut", { enumerable: true, get: function () { return api_1.apiPut; } });
+Object.defineProperty(exports, "apiPatch", { enumerable: true, get: function () { return api_1.apiPatch; } });
+Object.defineProperty(exports, "apiDelete", { enumerable: true, get: function () { return api_1.apiDelete; } });
+Object.defineProperty(exports, "apiCallSafe", { enumerable: true, get: function () { return api_1.apiCallSafe; } });

package/dist/http/index.d.ts

@@ -0,0 +1,2 @@
+export { HTTP_STATUS, type HttpStatus } from './status';
+export { type ErrorResponse, badRequestResponse, unauthorizedResponse, forbiddenResponse, notFoundResponse, conflictResponse, handleFunctionError, isNotFoundError, isConflictError } from './responses';

package/dist/http/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConflictError = exports.isNotFoundError = exports.handleFunctionError = exports.conflictResponse = exports.notFoundResponse = exports.forbiddenResponse = exports.unauthorizedResponse = exports.badRequestResponse = exports.HTTP_STATUS = void 0;
+var status_1 = require("./status");
+Object.defineProperty(exports, "HTTP_STATUS", { enumerable: true, get: function () { return status_1.HTTP_STATUS; } });
+var responses_1 = require("./responses");
+Object.defineProperty(exports, "badRequestResponse", { enumerable: true, get: function () { return responses_1.badRequestResponse; } });
+Object.defineProperty(exports, "unauthorizedResponse", { enumerable: true, get: function () { return responses_1.unauthorizedResponse; } });
+Object.defineProperty(exports, "forbiddenResponse", { enumerable: true, get: function () { return responses_1.forbiddenResponse; } });
+Object.defineProperty(exports, "notFoundResponse", { enumerable: true, get: function () { return responses_1.notFoundResponse; } });
+Object.defineProperty(exports, "conflictResponse", { enumerable: true, get: function () { return responses_1.conflictResponse; } });
+Object.defineProperty(exports, "handleFunctionError", { enumerable: true, get: function () { return responses_1.handleFunctionError; } });
+Object.defineProperty(exports, "isNotFoundError", { enumerable: true, get: function () { return responses_1.isNotFoundError; } });
+Object.defineProperty(exports, "isConflictError", { enumerable: true, get: function () { return responses_1.isConflictError; } });

package/dist/http/responses.d.ts

@@ -0,0 +1,40 @@
+import { HttpResponseInit, InvocationContext } from '@azure/functions';
+/**
+ * Standard error response structure
+ */
+export interface ErrorResponse {
+    error: string;
+    details?: string;
+}
+/**
+ * Create a 400 Bad Request response
+ */
+export declare function badRequestResponse(message: string): HttpResponseInit;
+/**
+ * Create a 401 Unauthorized response
+ */
+export declare function unauthorizedResponse(message?: string): HttpResponseInit;
+/**
+ * Create a 403 Forbidden response
+ */
+export declare function forbiddenResponse(message?: string): HttpResponseInit;
+/**
+ * Create a 404 Not Found response
+ */
+export declare function notFoundResponse(resource: string): HttpResponseInit;
+/**
+ * Create a 409 Conflict response
+ */
+export declare function conflictResponse(message: string): HttpResponseInit;
+/**
+ * Handle unexpected errors safely (logs details, returns generic message)
+ */
+export declare function handleFunctionError(error: unknown, context: InvocationContext): HttpResponseInit;
+/**
+ * Check if an Azure Table Storage error is "not found"
+ */
+export declare function isNotFoundError(error: unknown): boolean;
+/**
+ * Check if an Azure Table Storage error is "conflict"
+ */
+export declare function isConflictError(error: unknown): boolean;

package/dist/http/responses.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.badRequestResponse = badRequestResponse;
+exports.unauthorizedResponse = unauthorizedResponse;
+exports.forbiddenResponse = forbiddenResponse;
+exports.notFoundResponse = notFoundResponse;
+exports.conflictResponse = conflictResponse;
+exports.handleFunctionError = handleFunctionError;
+exports.isNotFoundError = isNotFoundError;
+exports.isConflictError = isConflictError;
+const status_1 = require("./status");
+/**
+ * Create a 400 Bad Request response
+ */
+function badRequestResponse(message) {
+    return {
+        status: status_1.HTTP_STATUS.BAD_REQUEST,
+        jsonBody: { error: message }
+    };
+}
+/**
+ * Create a 401 Unauthorized response
+ */
+function unauthorizedResponse(message = 'Unauthorized') {
+    return {
+        status: status_1.HTTP_STATUS.UNAUTHORIZED,
+        jsonBody: { error: message }
+    };
+}
+/**
+ * Create a 403 Forbidden response
+ */
+function forbiddenResponse(message = 'Forbidden') {
+    return {
+        status: status_1.HTTP_STATUS.FORBIDDEN,
+        jsonBody: { error: message }
+    };
+}
+/**
+ * Create a 404 Not Found response
+ */
+function notFoundResponse(resource) {
+    return {
+        status: status_1.HTTP_STATUS.NOT_FOUND,
+        jsonBody: { error: `${resource} not found` }
+    };
+}
+/**
+ * Create a 409 Conflict response
+ */
+function conflictResponse(message) {
+    return {
+        status: status_1.HTTP_STATUS.CONFLICT,
+        jsonBody: { error: message }
+    };
+}
+/**
+ * Handle unexpected errors safely (logs details, returns generic message)
+ */
+function handleFunctionError(error, context) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    context.error(`Function error: ${message}`);
+    return {
+        status: status_1.HTTP_STATUS.INTERNAL_ERROR,
+        jsonBody: { error: 'Internal server error' }
+    };
+}
+/**
+ * Check if an Azure Table Storage error is "not found"
+ */
+function isNotFoundError(error) {
+    return (error instanceof Error &&
+        'statusCode' in error &&
+        error.statusCode === 404);
+}
+/**
+ * Check if an Azure Table Storage error is "conflict"
+ */
+function isConflictError(error) {
+    return (error instanceof Error &&
+        'statusCode' in error &&
+        error.statusCode === 409);
+}

package/dist/http/status.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HTTP status codes - use instead of magic numbers
+ */
+export declare const HTTP_STATUS: {
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly NO_CONTENT: 204;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly CONFLICT: 409;
+    readonly GONE: 410;
+    readonly INTERNAL_ERROR: 500;
+    readonly SERVICE_UNAVAILABLE: 503;
+};
+export type HttpStatus = typeof HTTP_STATUS[keyof typeof HTTP_STATUS];

package/dist/http/status.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_STATUS = void 0;
+/**
+ * HTTP status codes - use instead of magic numbers
+ */
+exports.HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    NO_CONTENT: 204,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    CONFLICT: 409,
+    GONE: 410,
+    INTERNAL_ERROR: 500,
+    SERVICE_UNAVAILABLE: 503
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './auth';
+export * from './http';
+export * from './storage';
+export * from './client';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Main entry point - re-export everything
+__exportStar(require("./auth"), exports);
+__exportStar(require("./http"), exports);
+__exportStar(require("./storage"), exports);
+__exportStar(require("./client"), exports);

package/dist/storage/client.d.ts

@@ -0,0 +1,25 @@
+import { TableClient } from '@azure/data-tables';
+/**
+ * Initialize storage configuration - call once at startup
+ */
+export declare function initStorage(config: {
+    accountName?: string;
+    connectionString?: string;
+}): void;
+/**
+ * Auto-initialize from environment variables
+ */
+export declare function initStorageFromEnv(): void;
+/**
+ * Check if using managed identity (Azure) vs connection string (local)
+ */
+export declare function useManagedIdentity(): boolean;
+/**
+ * Get a TableClient for the specified table
+ * Creates table if it doesn't exist, caches client for reuse
+ */
+export declare function getTableClient(tableName: string): Promise<TableClient>;
+/**
+ * Clear the client cache (useful for testing)
+ */
+export declare function clearTableClientCache(): void;

package/dist/storage/client.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initStorage = initStorage;
+exports.initStorageFromEnv = initStorageFromEnv;
+exports.useManagedIdentity = useManagedIdentity;
+exports.getTableClient = getTableClient;
+exports.clearTableClientCache = clearTableClientCache;
+const data_tables_1 = require("@azure/data-tables");
+const identity_1 = require("@azure/identity");
+/**
+ * Azure Table Storage client factory with managed identity support
+ */
+// Cache table clients to avoid repeated connections
+const tableClients = new Map();
+// Configuration
+let storageAccountName;
+let connectionString;
+/**
+ * Initialize storage configuration - call once at startup
+ */
+function initStorage(config) {
+    storageAccountName = config.accountName;
+    connectionString = config.connectionString;
+}
+/**
+ * Auto-initialize from environment variables
+ */
+function initStorageFromEnv() {
+    initStorage({
+        accountName: process.env.STORAGE_ACCOUNT_NAME,
+        connectionString: process.env.AzureWebJobsStorage
+    });
+}
+/**
+ * Check if using managed identity (Azure) vs connection string (local)
+ */
+function useManagedIdentity() {
+    return !!storageAccountName && !connectionString?.includes('UseDevelopmentStorage');
+}
+/**
+ * Get a TableClient for the specified table
+ * Creates table if it doesn't exist, caches client for reuse
+ */
+async function getTableClient(tableName) {
+    // Return cached client if available
+    const cached = tableClients.get(tableName);
+    if (cached) {
+        return cached;
+    }
+    let client;
+    if (useManagedIdentity()) {
+        // Azure: Use managed identity
+        const credential = new identity_1.DefaultAzureCredential();
+        const endpoint = `https://${storageAccountName}.table.core.windows.net`;
+        client = new data_tables_1.TableClient(endpoint, tableName, credential);
+    }
+    else if (connectionString) {
+        // Local/Azurite: Use connection string
+        client = data_tables_1.TableClient.fromConnectionString(connectionString, tableName);
+    }
+    else {
+        throw new Error('Storage not configured. Set STORAGE_ACCOUNT_NAME or AzureWebJobsStorage.');
+    }
+    // Create table if it doesn't exist
+    try {
+        await client.createTable();
+    }
+    catch (error) {
+        // Ignore "table already exists" errors (409 Conflict)
+        const tableError = error;
+        if (tableError.statusCode !== 409) {
+            throw error;
+        }
+    }
+    // Cache and return
+    tableClients.set(tableName, client);
+    return client;
+}
+/**
+ * Clear the client cache (useful for testing)
+ */
+function clearTableClientCache() {
+    tableClients.clear();
+}

package/dist/storage/helpers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generate a unique row key from an identifier string
+ * Uses SHA-256 hash for consistent, URL-safe keys
+ *
+ * @param identifier - The string to hash (e.g., subscription endpoint, user ID)
+ * @returns A 32-character hex string suitable for Azure Table Storage row keys
+ */
+export declare function generateRowKey(identifier: string): string;

package/dist/storage/helpers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRowKey = generateRowKey;
+const crypto_1 = require("crypto");
+/**
+ * Generate a unique row key from an identifier string
+ * Uses SHA-256 hash for consistent, URL-safe keys
+ *
+ * @param identifier - The string to hash (e.g., subscription endpoint, user ID)
+ * @returns A 32-character hex string suitable for Azure Table Storage row keys
+ */
+function generateRowKey(identifier) {
+    return (0, crypto_1.createHash)('sha256').update(identifier).digest('hex').substring(0, 32);
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { initStorage, initStorageFromEnv, useManagedIdentity, getTableClient, clearTableClientCache } from './client';
+export { generateRowKey } from './helpers';

package/dist/storage/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRowKey = exports.clearTableClientCache = exports.getTableClient = exports.useManagedIdentity = exports.initStorageFromEnv = exports.initStorage = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "initStorage", { enumerable: true, get: function () { return client_1.initStorage; } });
+Object.defineProperty(exports, "initStorageFromEnv", { enumerable: true, get: function () { return client_1.initStorageFromEnv; } });
+Object.defineProperty(exports, "useManagedIdentity", { enumerable: true, get: function () { return client_1.useManagedIdentity; } });
+Object.defineProperty(exports, "getTableClient", { enumerable: true, get: function () { return client_1.getTableClient; } });
+Object.defineProperty(exports, "clearTableClientCache", { enumerable: true, get: function () { return client_1.clearTableClientCache; } });
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "generateRowKey", { enumerable: true, get: function () { return helpers_1.generateRowKey; } });

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@markwharton/pwa-core",
+  "version": "1.0.0",
+  "description": "Shared patterns for Azure PWA projects",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./auth": "./dist/auth/index.js",
+    "./http": "./dist/http/index.js",
+    "./storage": "./dist/storage/index.js",
+    "./client": "./dist/client/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "@azure/data-tables": "^13.0.0",
+    "@azure/identity": "^4.0.0",
+    "jsonwebtoken": "^9.0.0"
+  },
+  "devDependencies": {
+    "@azure/data-tables": "^13.2.2",
+    "@azure/functions": "^4.5.0",
+    "@azure/identity": "^4.5.0",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/node": "^20.10.0",
+    "jsonwebtoken": "^9.0.2",
+    "typescript": "^5.3.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MarkWharton/pwa-packages.git",
+    "directory": "packages/core"
+  },
+  "author": "Mark Wharton",
+  "license": "MIT"
+}