@shiftapi/next 0.0.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Frank Chiarulli Jr.
+
+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/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { ShiftAPIPluginOptions } from 'shiftapi/internal';
+export { ShiftAPIPluginOptions } from 'shiftapi/internal';
+export { ShiftAPIConfig, defineConfig } from 'shiftapi';
+
+type NextConfigObject = Record<string, unknown>;
+type NextConfigFunction = (...args: unknown[]) => NextConfigObject | Promise<NextConfigObject>;
+type NextConfig = NextConfigObject | NextConfigFunction;
+/**
+ * Wraps a Next.js config with ShiftAPI integration (Go server management,
+ * typed API client generation, dev proxy).
+ *
+ * Supports both object and function configs.
+ *
+ * @param nextConfig - The user's exported Next.js config
+ * @param opts - ShiftAPI-specific options
+ * @returns The wrapped Next.js config (same shape as the input)
+ */
+declare function withShiftAPI<C extends NextConfig>(nextConfig?: C, opts?: ShiftAPIPluginOptions): C;
+
+export { withShiftAPI };

package/dist/index.js

@@ -0,0 +1,228 @@
+// src/index.ts
+import { resolve } from "path";
+import { watch } from "fs";
+import { createRequire } from "module";
+import {
+  loadConfig,
+  findConfigDir,
+  regenerateTypes as _regenerateTypes,
+  writeGeneratedFiles,
+  patchTsConfig,
+  nextClientJsTemplate,
+  DEV_API_PREFIX,
+  GoServerManager,
+  findFreePort
+} from "shiftapi/internal";
+import { defineConfig } from "shiftapi";
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function withShiftAPI(nextConfig, opts) {
+  const cast = nextConfig ?? {};
+  if (typeof cast === "function") {
+    return function(...args) {
+      const result = cast.apply(this, args);
+      if (isThenable(result)) {
+        return result.then(
+          (cfg) => applyShiftAPI(cfg, opts)
+        );
+      }
+      return applyShiftAPI(result, opts);
+    };
+  }
+  return applyShiftAPI(cast, opts);
+}
+function applyShiftAPI(nextConfig, opts) {
+  const projectRoot = process.cwd();
+  const configDir = findConfigDir(projectRoot, opts?.configPath);
+  if (!configDir) {
+    console.warn(
+      "[shiftapi] Could not find shiftapi.config.ts. Skipping ShiftAPI integration."
+    );
+    return nextConfig;
+  }
+  const isDev = process.env.NODE_ENV !== "production";
+  const shiftapiClientPath = resolve(configDir, ".shiftapi", "client.js");
+  const require2 = createRequire(import.meta.url);
+  const openapiPath = require2.resolve("openapi-fetch");
+  const initPromise = initializeAsync(projectRoot, configDir, isDev, opts);
+  const patched = { ...nextConfig };
+  const existingWebpack = nextConfig.webpack;
+  patched.webpack = (config, context) => {
+    const cfg = existingWebpack ? existingWebpack(config, context) : config;
+    cfg.resolve = cfg.resolve || {};
+    cfg.resolve.alias = cfg.resolve.alias || {};
+    cfg.resolve.alias["@shiftapi/client"] = shiftapiClientPath;
+    cfg.resolve.alias["openapi-fetch"] = openapiPath;
+    cfg.plugins = cfg.plugins || [];
+    cfg.plugins.push({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      apply(compiler) {
+        compiler.hooks.beforeCompile.tapPromise("ShiftAPI", async () => {
+          await initPromise;
+        });
+      }
+    });
+    return cfg;
+  };
+  const existingExperimental = nextConfig.experimental ?? {};
+  const existingTurbo = existingExperimental.turbo ?? {};
+  const existingResolveAlias = existingTurbo.resolveAlias ?? {};
+  patched.experimental = {
+    ...existingExperimental,
+    turbo: {
+      ...existingTurbo,
+      resolveAlias: {
+        ...existingResolveAlias,
+        "@shiftapi/client": shiftapiClientPath,
+        "openapi-fetch": openapiPath
+      }
+    }
+  };
+  if (isDev) {
+    const existingRewrites = nextConfig.rewrites;
+    patched.rewrites = async () => {
+      const { port } = await initPromise;
+      const shiftapiRewrite = {
+        source: `${DEV_API_PREFIX}/:path*`,
+        destination: `http://localhost:${port}/:path*`
+      };
+      if (!existingRewrites) {
+        return {
+          beforeFiles: [shiftapiRewrite],
+          afterFiles: [],
+          fallback: []
+        };
+      }
+      const existing = await existingRewrites();
+      if (Array.isArray(existing)) {
+        return {
+          beforeFiles: [shiftapiRewrite],
+          afterFiles: existing,
+          fallback: []
+        };
+      }
+      return {
+        beforeFiles: [shiftapiRewrite, ...existing.beforeFiles ?? []],
+        afterFiles: existing.afterFiles ?? [],
+        fallback: existing.fallback ?? []
+      };
+    };
+  }
+  return patched;
+}
+async function initializeAsync(projectRoot, configDir, isDev, opts) {
+  const { config } = await loadConfig(projectRoot, opts?.configPath);
+  const serverEntry = config.server;
+  const baseUrl = config.baseUrl ?? "/";
+  const goRoot = configDir;
+  const parsedUrl = new URL(config.url ?? "http://localhost:8080");
+  const basePort = parseInt(parsedUrl.port || "8080");
+  if (isDev) {
+    return initializeDev(
+      projectRoot,
+      configDir,
+      serverEntry,
+      baseUrl,
+      goRoot,
+      parsedUrl,
+      basePort
+    );
+  }
+  return initializeBuild(projectRoot, configDir, serverEntry, baseUrl, goRoot, basePort);
+}
+async function initializeDev(projectRoot, configDir, serverEntry, baseUrl, goRoot, parsedUrl, basePort) {
+  const goPort = await findFreePort(basePort);
+  if (goPort !== basePort) {
+    console.log(`[shiftapi] Port ${basePort} is in use, using ${goPort}`);
+  }
+  const goServer = new GoServerManager(serverEntry, goRoot);
+  try {
+    await goServer.start(goPort);
+    console.log(
+      `[shiftapi] API docs available at ${parsedUrl.protocol}//${parsedUrl.hostname}:${goPort}/docs`
+    );
+  } catch (err) {
+    console.error("[shiftapi] Go server failed to start:", err);
+  }
+  let generatedDts = "";
+  try {
+    const result = await _regenerateTypes(serverEntry, goRoot, baseUrl, true, "");
+    generatedDts = result.types;
+    const clientJs = nextClientJsTemplate(goPort, baseUrl);
+    writeGeneratedFiles(configDir, generatedDts, baseUrl, { clientJsContent: clientJs });
+    patchTsConfig(projectRoot, configDir);
+    console.log("[shiftapi] Types generated.");
+  } catch (err) {
+    console.error("[shiftapi] Failed to generate types:", err);
+  }
+  let debounceTimer = null;
+  let watcher;
+  try {
+    watcher = watch(resolve(goRoot), { recursive: true }, (_event, filename) => {
+      if (!filename || !filename.endsWith(".go")) return;
+      console.log(`[shiftapi] Go file changed: ${filename}`);
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(async () => {
+        try {
+          await goServer.stop();
+          await goServer.start(goPort);
+          const result = await _regenerateTypes(
+            serverEntry,
+            goRoot,
+            baseUrl,
+            true,
+            generatedDts
+          );
+          if (result.changed) {
+            generatedDts = result.types;
+            const clientJs = nextClientJsTemplate(goPort, baseUrl);
+            writeGeneratedFiles(configDir, generatedDts, baseUrl, {
+              clientJsContent: clientJs
+            });
+            console.log("[shiftapi] Types regenerated.");
+          }
+        } catch (err) {
+          console.error("[shiftapi] Failed to regenerate:", err);
+        }
+      }, 500);
+    });
+  } catch {
+    console.warn("[shiftapi] Could not set up file watcher for Go files.");
+  }
+  function cleanup() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    watcher?.close();
+    goServer.forceKill();
+  }
+  process.on("exit", cleanup);
+  process.on("SIGINT", async () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    watcher?.close();
+    await goServer.stop();
+    process.exit();
+  });
+  process.on("SIGTERM", async () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    watcher?.close();
+    await goServer.stop();
+    process.exit();
+  });
+  return { port: goPort };
+}
+async function initializeBuild(projectRoot, configDir, serverEntry, baseUrl, goRoot, basePort) {
+  try {
+    const result = await _regenerateTypes(serverEntry, goRoot, baseUrl, false, "");
+    const clientJs = nextClientJsTemplate(basePort, baseUrl);
+    writeGeneratedFiles(configDir, result.types, baseUrl, { clientJsContent: clientJs });
+    patchTsConfig(projectRoot, configDir);
+    console.log("[shiftapi] Types generated for build.");
+  } catch (err) {
+    console.error("[shiftapi] Failed to generate types for build:", err);
+  }
+  return { port: basePort };
+}
+export {
+  defineConfig,
+  withShiftAPI
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@shiftapi/next",
+  "version": "0.0.15",
+  "description": "Next.js integration for fully-typed TypeScript clients from shiftapi Go servers",
+  "author": "Frank Chiarulli Jr. <frank@frankchiarulli.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/fcjr/shiftapi",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fcjr/shiftapi",
+    "directory": "packages/next"
+  },
+  "bugs": {
+    "url": "https://github.com/fcjr/shiftapi/issues"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "next": ">=14.0.0"
+  },
+  "dependencies": {
+    "openapi-fetch": "^0.13.0",
+    "shiftapi": "0.0.15"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "next": "^15.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch"
+  }
+}