opennextjs-azure 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zach Grimaldi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# OpenNext.js Azure
+
+**True serverless Next.js on Azure Functions**
+
+[![NPM Version](https://img.shields.io/npm/v/opennextjs-azure)](https://www.npmjs.com/package/opennextjs-azure)
+[![NPM Downloads](https://img.shields.io/npm/dt/opennextjs-azure)](https://www.npmjs.com/package/opennextjs-azure)
+[![License: MIT](https://img.shields.io/npm/l/opennextjs-azure)](https://opensource.org/licenses/MIT)
+
+Built on the [OpenNext](https://opennext.js.org) framework, this adapter brings native Next.js support to Azure Functions.
+
+> **🚀 New to Azure deployment?** Jump to [Quick Start](#quick-start) and run `npx opennextjs-azure@latest init --scaffold` to create a fully configured Next.js app on Azure in seconds!
+
+## The Gap This Project Fills
+
+Tutorials exist for static Next.js on Static Web Apps, standalone builds on App Service, and Docker-based deployments, but nothing for **true serverless Next.js on Azure Functions** with ISR, streaming SSR, and on-demand revalidation—until now.
+
+Azure Functions is Microsoft's serverless compute platform—comparable to AWS Lambda and Cloudflare Workers, both of which already have OpenNext adapters. This project bridges that gap, bringing the same Vercel-grade developer experience to Azure: one command deploys your Next.js app with all the infrastructure you need.
+
+## Next.js Features → Azure Services
+
+| Next.js Feature                        | Azure Implementation                                            |
+| -------------------------------------- | --------------------------------------------------------------- |
+| Incremental Static Regeneration        | Azure Blob Storage                                              |
+| Streaming SSR                          | Azure Functions with Node.js streams                            |
+| `revalidateTag()` / `revalidatePath()` | Azure Table Storage + Queue Storage                             |
+| Fetch caching                          | Azure Blob Storage with build ID namespacing                    |
+| Monitoring & Logging                   | Azure Application Insights (optional, enabled by default)       |
+| Infrastructure                         | Azure Bicep templates upsert infrastructure in a resource group |
+
+## Quick Start
+
+### ⚡ Recommended: Create New Project with Scaffold
+
+**The fastest way to get started** is using our scaffold command, which wraps `create-next-app` and sets up everything for Azure deployment:
+
+```bash
+npx opennextjs-azure@latest init --scaffold
+```
+
+This single command:
+
+1. Creates a new Next.js 15 app (TypeScript, App Router, Tailwind, ESLint)
+2. Adds Azure deployment dependencies (`opennextjs-azure`, `esbuild`)
+3. Configures `next.config.ts` with `output: "standalone"`
+4. Creates `open-next.config.ts` with Azure adapters
+5. Generates `infrastructure/main.bicep` for Azure resources
+6. Sets up `azure.config.json` for deployment configuration
+
+Then build and deploy:
+
+```bash
+npx opennextjs-azure build
+npx opennextjs-azure deploy
+```
+
+**💡 See it in action:** The [`examples/basic-app`](./examples/basic-app) directory (live at https://opennext-basic-app-func-dev.azurewebsites.net) was created using `init --scaffold` with zero manual configuration!
+
+### 📦 Adding to Existing Project
+
+If you have an existing Next.js project:
+
+```bash
+# Initialize Azure infrastructure
+npx opennextjs-azure init
+
+# Build for Azure
+npx opennextjs-azure build
+
+# Deploy (provisions infrastructure + deploys app)
+npx opennextjs-azure deploy
+
+# View live logs in Azure Portal
+npx opennextjs-azure tail
+```
+
+## Intelligent Preflight Checks
+
+Before deployment, the CLI validates your Azure environment to prevent failed deployments:
+
+✓ **Azure CLI** installation and login status  
+✓ **Subscription** permissions and state  
+✓ **Region** availability  
+✓ **Resource providers** (auto-registers Microsoft.Quota, Microsoft.Storage, Microsoft.AlertsManagement, etc.)  
+✓ **Quota availability** for your target SKU  
+✓ **Build output** structure
+
+**Smart quota handling:** If you request `--environment prod` but don't have EP1 Premium quota, the CLI suggests `--environment dev` instead. Zero failed deployments from quota issues.
+
+## Architecture
+
+```
+Next.js Request
+    ↓
+Azure Functions HTTP Trigger
+    ↓
+Azure HTTP Converter (request → InternalEvent)
+    ↓
+Azure Functions Wrapper (handles streaming)
+    ↓
+Next.js Server (OpenNext)
+    ↓
+ISR Cache Check → Azure Blob Storage
+Tag Check → Azure Table Storage
+Revalidation → Azure Queue Storage
+    ↓
+Response Stream → Azure Functions Response
+```
+
+## One Command, Full Infrastructure
+
+`opennextjs-azure deploy` provisions everything via Bicep:
+
+- Function App (with streaming support)
+- Storage Account (blob containers, tables, queues)
+- App Service Plan (Y1 Consumption or EP1 Premium)
+- Application Insights (optional, for monitoring and logging)
+- CORS configuration
+- Environment variables
+- Connection strings
+
+Choose your environment:
+
+- `--environment dev` → Y1 Consumption (pay-per-execution)
+- `--environment staging` → EP1 Premium (always-ready instances)
+- `--environment prod` → EP1 Premium (production-grade)
+
+## How It Works
+
+**Protocol Adapters:**  
+Converts between Azure Functions HTTP triggers and Next.js InternalEvent/InternalResult format with full streaming support.
+
+**ISR Implementation:**
+
+- **Incremental Cache:** Azure Blob Storage stores rendered pages with `[buildId]/[key].cache` structure
+- **Tag Cache:** Azure Table Storage maps tags → paths for `revalidateTag()`
+- **Revalidation Queue:** Azure Queue Storage triggers on-demand regeneration
+
+**Build Process:**  
+Uses OpenNext's AWS build with Azure-specific overrides, then adds Azure Functions metadata (`host.json`, `function.json`) for v3 programming model.
+
+## CLI Commands
+
+### `init --scaffold` (Recommended for new projects)
+
+Creates a complete Next.js + Azure setup in one command:
+
+```bash
+npx opennextjs-azure@latest init --scaffold
+```
+
+This wraps `create-next-app` with Azure-specific setup. Supports all create-next-app options:
+
+```bash
+# Customize the scaffold
+opennextjs-azure init --scaffold \
+  [--no-typescript] \
+  [--no-tailwind] \
+  [--no-eslint] \
+  [--no-src-dir] \
+  [--no-app-router] \
+  [--import-alias <alias>] \
+  [--package-manager npm|yarn|pnpm|bun]
+```
+
+### Other Commands
+
+```bash
+# Initialize Azure infrastructure in existing project
+opennextjs-azure init
+
+# Build Next.js app for Azure
+opennextjs-azure build [-c <config-path>]
+
+# Deploy to Azure
+opennextjs-azure deploy \
+  [--app-name <name>] \
+  [--resource-group <name>] \
+  [--location <region>] \
+  [--environment dev|staging|prod] \
+  [--skip-infrastructure]
+
+# View live logs in Azure Portal
+opennextjs-azure tail \
+  [--app-name <name>] \
+  [--resource-group <name>]
+```
+
+## License
+
+[MIT](./LICENSE)
+
+## Contributing
+
+Contributions are welcome! Whether it's bug fixes, feature additions, or documentation improvements, we appreciate your help in making this project better. For major changes or new features, please open an issue first to discuss what you would like to change.

package/dist/adapters/converters/azure-http.d.mts

@@ -0,0 +1,22 @@
+import { HttpRequest } from '@azure/functions';
+import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
+
+/**
+ * Converts Azure HTTP requests to OpenNext InternalEvent format
+ */
+declare function convertFromAzureHttp(request: HttpRequest): Promise<InternalEvent>;
+/**
+ * Converts OpenNext InternalResult to Azure HTTP response
+ */
+declare function convertToAzureHttp(result: InternalResult): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}>;
+declare const _default: {
+    convertFrom: typeof convertFromAzureHttp;
+    convertTo: typeof convertToAzureHttp;
+    name: string;
+};
+
+export { _default as default };

package/dist/adapters/converters/azure-http.d.ts

@@ -0,0 +1,22 @@
+import { HttpRequest } from '@azure/functions';
+import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
+
+/**
+ * Converts Azure HTTP requests to OpenNext InternalEvent format
+ */
+declare function convertFromAzureHttp(request: HttpRequest): Promise<InternalEvent>;
+/**
+ * Converts OpenNext InternalResult to Azure HTTP response
+ */
+declare function convertToAzureHttp(result: InternalResult): Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}>;
+declare const _default: {
+    convertFrom: typeof convertFromAzureHttp;
+    convertTo: typeof convertToAzureHttp;
+    name: string;
+};
+
+export { _default as default };

package/dist/adapters/converters/azure-http.js

@@ -0,0 +1,97 @@
+import { Buffer } from 'node:buffer';
+
+async function convertFromAzureHttp(request) {
+  const url = new URL(request.url);
+  let pathname = url.pathname;
+  pathname = normalizePath(pathname);
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    const existing = query[key];
+    if (existing) {
+      query[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+    } else {
+      query[key] = value;
+    }
+  });
+  const headers = {};
+  for (const [key, value] of Object.entries(request.headers)) {
+    if (value) {
+      headers[key.toLowerCase()] = value;
+    }
+  }
+  const cookies = {};
+  const cookieHeader = headers.cookie;
+  if (cookieHeader) {
+    cookieHeader.split(";").forEach((cookie) => {
+      const [key, ...valueParts] = cookie.trim().split("=");
+      if (key) {
+        cookies[key] = valueParts.join("=");
+      }
+    });
+  }
+  const body = request.method !== "GET" && request.method !== "HEAD" ? Buffer.from(await request.arrayBuffer()) : void 0;
+  return {
+    type: "core",
+    method: request.method,
+    rawPath: pathname,
+    url: request.url,
+    body,
+    headers,
+    query,
+    cookies,
+    remoteAddress: headers["x-forwarded-for"] || headers["x-real-ip"] || "::1"
+  };
+}
+function normalizePath(pathname) {
+  if (!pathname || pathname === "/" || pathname === "") {
+    return "/";
+  }
+  if (!pathname.startsWith("/")) {
+    pathname = "/" + pathname;
+  }
+  return pathname;
+}
+async function convertToAzureHttp(result) {
+  const headers = {};
+  for (const [key, value] of Object.entries(result.headers)) {
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      headers[key] = value.join(", ");
+    } else {
+      headers[key] = String(value);
+    }
+  }
+  let body;
+  if (result.body) {
+    const chunks = [];
+    const reader = result.body.getReader();
+    try {
+      let done = false;
+      while (!done) {
+        const result2 = await reader.read();
+        done = result2.done;
+        if (result2.value) {
+          chunks.push(result2.value);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const buffer = Buffer.concat(chunks);
+    body = result.isBase64Encoded ? buffer.toString("base64") : buffer.toString("utf8");
+  }
+  return {
+    status: result.statusCode,
+    headers,
+    body
+  };
+}
+const azureHttp = {
+  convertFrom: convertFromAzureHttp,
+  convertTo: convertToAzureHttp,
+  name: "azure-http"
+};
+
+export { azureHttp as default };

package/dist/adapters/wrappers/azure-functions.d.mts

@@ -0,0 +1,10 @@
+import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
+import { WrapperHandler } from '@opennextjs/aws/types/overrides.js';
+
+declare const _default: {
+    wrapper: WrapperHandler<InternalEvent, InternalResult>;
+    name: string;
+    supportStreaming: true;
+};
+
+export { _default as default };

package/dist/adapters/wrappers/azure-functions.d.ts

@@ -0,0 +1,10 @@
+import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
+import { WrapperHandler } from '@opennextjs/aws/types/overrides.js';
+
+declare const _default: {
+    wrapper: WrapperHandler<InternalEvent, InternalResult>;
+    name: string;
+    supportStreaming: true;
+};
+
+export { _default as default };

package/dist/adapters/wrappers/azure-functions.js

@@ -0,0 +1,102 @@
+import { Writable } from 'node:stream';
+
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+const STATIC_ASSET_PATTERNS = [
+  /^\/_next\/static\//,
+  /^\/_next\/data\//,
+  /^\/favicon\.ico$/,
+  /^\/robots\.txt$/,
+  /^\/sitemap\.xml$/,
+  /^\/[^\/]+\.(svg|png|jpg|jpeg|gif|webp|ico|woff|woff2|ttf|eot)$/
+];
+function isStaticAssetRequest(pathname) {
+  return STATIC_ASSET_PATTERNS.some((pattern) => pattern.test(pathname));
+}
+const handler = async (handler2, converter) => async (context, request) => {
+  try {
+    const internalEvent = await converter.convertFrom(request);
+    if (isStaticAssetRequest(internalEvent.rawPath)) {
+      const blobUrl = `https://${process.env.AZURE_STORAGE_ACCOUNT_NAME}.blob.core.windows.net/assets${internalEvent.rawPath}`;
+      context.res = {
+        status: 301,
+        headers: {
+          Location: blobUrl,
+          "Cache-Control": "public, max-age=31536000, immutable"
+        }
+      };
+      return;
+    }
+    let streamFinished = null;
+    let resolveStream = null;
+    const streamCreator = {
+      writeHeaders(prelude) {
+        const { statusCode, cookies, headers } = prelude;
+        const responseHeaders = { ...headers };
+        if (cookies.length > 0) {
+          responseHeaders["set-cookie"] = cookies.join(", ");
+        }
+        if (NULL_BODY_STATUSES.has(statusCode)) {
+          context.res = {
+            status: statusCode,
+            headers: responseHeaders
+          };
+          return new Writable({
+            write(chunk, encoding, callback) {
+              callback();
+            }
+          });
+        }
+        const chunks = [];
+        streamFinished = new Promise((resolve) => {
+          resolveStream = resolve;
+        });
+        return new Writable({
+          write(chunk, encoding, callback) {
+            chunks.push(chunk);
+            callback();
+          },
+          final(callback) {
+            const body = Buffer.concat(chunks);
+            const bodyString = body.toString("utf8");
+            context.res = {
+              status: statusCode,
+              headers: responseHeaders,
+              body: bodyString
+            };
+            callback();
+            resolveStream?.();
+          }
+        });
+      },
+      retainChunks: true
+    };
+    await handler2(internalEvent, { streamCreator });
+    if (streamFinished) {
+      await streamFinished;
+    }
+    if (!context.res) {
+      context.res = {
+        status: 200,
+        headers: { "content-type": "text/html" },
+        body: ""
+      };
+    }
+  } catch (error) {
+    context.res = {
+      status: 500,
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        error: "Internal Server Error",
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      })
+    };
+  }
+};
+const azureFunctions = {
+  wrapper: handler,
+  name: "azure-functions",
+  supportStreaming: true
+};
+
+export { azureFunctions as default };

package/dist/cli/index.d.mts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/cli/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { i as init, b as build, d as deploy } from '../deploy.js';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import 'node:url';
+import '@opennextjs/aws/build.js';
+import 'node:fs';
+import 'node:readline';
+
+const execAsync = promisify(exec);
+async function tail(options) {
+  const cwd = process.cwd();
+  const configPath = path.join(cwd, "azure.config.json");
+  let config = {};
+  try {
+    const configContent = await fs.readFile(configPath, "utf-8");
+    config = JSON.parse(configContent);
+  } catch {
+    console.warn("\u26A0\uFE0F  azure.config.json not found.");
+    console.warn("    Provide --app-name and --resource-group or run from a project directory.\n");
+  }
+  const appName = options?.appName || config.appName;
+  const resourceGroup = options?.resourceGroup || config.resourceGroup;
+  const environment = config.environment || "dev";
+  if (!appName || !resourceGroup) {
+    console.error("\u274C Missing required information!");
+    console.error("   Provide --app-name and --resource-group or run from a project with azure.config.json\n");
+    process.exit(1);
+  }
+  const functionAppName = `${appName}-func-${environment}`;
+  console.log(`\u{1F4E1} Opening Azure Portal Log Stream for ${functionAppName}...
+`);
+  try {
+    const { stdout } = await execAsync("az account show --query '{tenant:tenantId, subscription:id}' -o json");
+    const account = JSON.parse(stdout);
+    const portalUrl = `https://portal.azure.com/#@${account.tenant}/resource/subscriptions/${account.subscription}/resourceGroups/${resourceGroup}/providers/Microsoft.Web/sites/${functionAppName}/logStream`;
+    console.log(`\u{1F310} Opening: ${portalUrl}
+`);
+    const openCommand = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    await execAsync(`${openCommand} "${portalUrl}"`);
+    console.log("\u2713 Log Stream page opened in your browser!");
+    console.log("\nTip: Enable Application Insights in azure.config.json for better log filtering.\n");
+  } catch (error) {
+    console.error(`
+\u274C Failed to open log stream: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+const program = new Command();
+program.name("opennextjs-azure").description("CLI tool for building and deploying Next.js apps to Azure").version("0.1.0");
+program.command("init").description("Initialize Azure infrastructure in your project").option("--scaffold", "Scaffold a new Next.js project if in empty directory").option("--no-typescript", "Disable TypeScript (default: enabled)").option("--no-tailwind", "Disable Tailwind CSS (default: enabled with v3)").option("--no-eslint", "Disable ESLint (default: enabled)").option("--no-src-dir", "Disable src/ directory (default: enabled)").option("--no-app-router", "Use Pages Router instead of App Router").option("--import-alias <alias>", "Import alias (default: @/*)").option("--package-manager <pm>", "Package manager: npm, yarn, pnpm, bun (default: pnpm)").action(async (options) => {
+  await init(options);
+});
+program.command("build").description("Build Next.js app for Azure deployment").option("-c, --config <path>", "Path to open-next.config.ts file").action(async (options) => {
+  await build(options.config);
+});
+program.command("deploy").description("Deploy Next.js app to Azure (provisions infrastructure + deploys)").option("-n, --app-name <name>", "Application name (overrides azure.config.json)").option("-g, --resource-group <name>", "Azure resource group name").option("-l, --location <location>", "Azure region").option("-e, --environment <env>", "Environment: dev, staging, or prod").option("--skip-infrastructure", "Skip infrastructure provisioning").action(async (options) => {
+  await deploy(options);
+});
+program.command("tail").description("Open Azure Portal Log Stream in browser (live logs)").option("-n, --app-name <name>", "Application name").option("-g, --resource-group <name>", "Azure resource group name").action(async (options) => {
+  await tail(options);
+});
+program.parse();

package/dist/config/index.d.mts

@@ -0,0 +1,3 @@
+import '@opennextjs/aws/types/open-next.js';
+export { d as defineAzureConfig, g as getAzureConfig } from '../shared/opennextjs-azure.d619537c.mjs';
+import '@opennextjs/aws/types/overrides.js';

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+import '@opennextjs/aws/types/open-next.js';
+export { d as defineAzureConfig, g as getAzureConfig } from '../shared/opennextjs-azure.d619537c.js';
+import '@opennextjs/aws/types/overrides.js';

package/dist/config/index.js

@@ -0,0 +1,68 @@
+function defineAzureConfig(config = {}) {
+  return {
+    default: {
+      override: {
+        wrapper: () => import('../adapters/wrappers/azure-functions.js').then((m) => m.default),
+        converter: () => import('../adapters/converters/azure-http.js').then((m) => m.default),
+        incrementalCache: resolveIncremental(config.incrementalCache),
+        tagCache: resolveTag(config.tagCache),
+        queue: resolveQueue(config.queue),
+        proxyExternalRequest: "fetch"
+      },
+      routePreloadingBehavior: config.routePreloadingBehavior || "none"
+    },
+    middleware: config.middleware || {
+      external: false
+    },
+    dangerous: config.dangerous,
+    buildCommand: config.buildCommand,
+    buildOutputPath: config.buildOutputPath || ".",
+    appPath: config.appPath || ".",
+    packageJsonPath: config.packageJsonPath
+  };
+}
+function resolveIncremental(value) {
+  if (!value || value === "azure-blob") {
+    return () => import('../overrides/incrementalCache/azure-blob.js').then((m) => new m.default());
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  return () => value;
+}
+function resolveTag(value) {
+  if (!value || value === "azure-table") {
+    return () => import('../overrides/tagCache/azure-table.js').then((m) => new m.default());
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  return () => value;
+}
+function resolveQueue(value) {
+  if (!value || value === "azure-queue") {
+    return () => import('../overrides/queue/azure-queue.js').then((m) => new m.default());
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  return () => value;
+}
+function getAzureConfig() {
+  return {
+    deployment: {
+      target: process.env.AZURE_DEPLOYMENT_TARGET || "functions",
+      region: process.env.AZURE_REGION || "eastus"
+    },
+    storage: {
+      connectionString: process.env.AZURE_STORAGE_CONNECTION_STRING,
+      accountName: process.env.AZURE_STORAGE_ACCOUNT_NAME,
+      accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY,
+      containerName: process.env.AZURE_STORAGE_CONTAINER_NAME || "nextjs-cache",
+      tableName: process.env.AZURE_TABLE_NAME || "nextjstags",
+      queueName: process.env.AZURE_QUEUE_NAME || "nextjsrevalidation"
+    }
+  };
+}
+
+export { defineAzureConfig, getAzureConfig };