@devup-api/next-plugin 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# @devup-api/next-plugin
+
+devup API plugin for Next.js
+
+## Installation
+
+```bash
+npm install @devup-api/next-plugin
+```
+
+## Usage
+
+```typescript
+import devupApiPlugin from '@devup-api/next-plugin';
+
+const nextConfig = {
+  // ... existing configuration
+  ...devupApiPlugin({
+    // options
+  }),
+};
+```

package/dist/__tests__/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/__tests__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/index.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/plugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin.test.d.ts.map

package/dist/__tests__/plugin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/plugin.test.ts"],"names":[],"mappings":""}

package/dist/index.cjs

@@ -0,0 +1 @@
+var{defineProperty:G,getOwnPropertyNames:Q,getOwnPropertyDescriptor:R}=Object,S=Object.prototype.hasOwnProperty;var H=new WeakMap,V=(x)=>{var q=H.get(x),z;if(q)return q;if(q=G({},"__esModule",{value:!0}),x&&typeof x==="object"||typeof x==="function")Q(x).map((y)=>!S.call(q,y)&&G(q,y,{get:()=>x[y],enumerable:!(z=R(x,y))||z.enumerable}));return H.set(x,q),q};var X=(x,q)=>{for(var z in q)G(x,z,{get:q[z],enumerable:!0,configurable:!0,set:(y)=>q[z]=()=>y})};var Y={};X(Y,{devupApi:()=>L,default:()=>L});module.exports=V(Y);var J=require("node:path"),F=require("@devup-api/generator"),A=require("@devup-api/utils"),K=require("@devup-api/webpack-plugin");function L(x,q={}){if(process.env.TURBOPACK==="1"||process.env.TURBOPACK==="auto"){let B=A.createTmpDir(q?.tempDir),E=A.readOpenapi(q?.openapiFile);A.writeInterface(J.join(B,"api.d.ts"),F.generateInterface(E,q));let N=F.createUrlMap(E,q);return x.env??={},Object.assign(x.env,{DEVUP_API_URL_MAP:JSON.stringify(N)}),x}let y=x.webpack;return x.webpack=(B,E)=>{if(B.plugins.push(new K.devupApiWebpackPlugin(q)),typeof y==="function")return y(B,E);return B},x}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin';
+export { devupApi as default } from './plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1 @@
+import{join as E}from"node:path";import{createUrlMap as F,generateInterface as G}from"@devup-api/generator";import{createTmpDir as H,readOpenapi as J,writeInterface as K}from"@devup-api/utils";import{devupApiWebpackPlugin as L}from"@devup-api/webpack-plugin";function N(x,q={}){if(process.env.TURBOPACK==="1"||process.env.TURBOPACK==="auto"){let y=H(q?.tempDir),z=J(q?.openapiFile);K(E(y,"api.d.ts"),G(z,q));let B=F(z,q);return x.env??={},Object.assign(x.env,{DEVUP_API_URL_MAP:JSON.stringify(B)}),x}let A=x.webpack;return x.webpack=(y,z)=>{if(y.plugins.push(new L(q)),typeof A==="function")return A(y,z);return y},x}export{N as devupApi,N as default};

package/dist/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { DevupApiOptions } from '@devup-api/core';
+import type { NextConfig } from 'next';
+export declare function devupApi(config: NextConfig, options?: DevupApiOptions): NextConfig;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAItD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAEtC,wBAAgB,QAAQ,CACtB,MAAM,EAAE,UAAU,EAClB,OAAO,GAAE,eAAoB,GAC5B,UAAU,CA2BZ"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@devup-api/next-plugin",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc && bun build --target node --outfile=dist/index.js src/index.ts --production --packages=external && bun build --target node --outfile=dist/index.cjs --format=cjs src/index.ts --production --packages=external"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@devup-api/utils": "0.1.0",
+    "@devup-api/core": "0.1.0",
+    "@devup-api/generator": "0.1.0",
+    "@devup-api/webpack-plugin": "0.1.0"
+  },
+  "peerDependencies": {
+    "next": "*",
+    "@devup-api/core": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10",
+    "@types/webpack": "^5.28",
+    "typescript": "^5.9"
+  }
+}

package/src/__tests__/index.test.ts

@@ -0,0 +1,9 @@
+import { expect, test } from 'bun:test'
+import * as indexModule from '../index'
+
+test('index.ts exports', () => {
+  expect({ ...indexModule }).toEqual({
+    devupApi: expect.any(Function),
+    default: expect.any(Function),
+  })
+})

package/src/__tests__/plugin.test.ts

@@ -0,0 +1,286 @@
+import { beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { join } from 'node:path'
+import type { DevupApiOptions } from '@devup-api/core'
+import * as generator from '@devup-api/generator'
+import * as utils from '@devup-api/utils'
+import { devupApiWebpackPlugin } from '@devup-api/webpack-plugin'
+import type { NextConfig } from 'next'
+import { devupApi } from '../plugin'
+
+let mockCreateTmpDir: ReturnType<typeof spyOn>
+let mockReadOpenapi: ReturnType<typeof spyOn>
+let mockWriteInterface: ReturnType<typeof spyOn>
+let mockCreateTmpDirAsync: ReturnType<typeof spyOn>
+let mockReadOpenapiAsync: ReturnType<typeof spyOn>
+let mockWriteInterfaceAsync: ReturnType<typeof spyOn>
+let mockCreateUrlMap: ReturnType<typeof spyOn>
+let mockGenerateInterface: ReturnType<typeof spyOn>
+
+const mockSchema = {
+  openapi: '3.1.0',
+  paths: {
+    '/users': {
+      get: {
+        operationId: 'getUsers',
+        responses: {
+          '200': {
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'array',
+                  items: { type: 'string' },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+} as const
+
+const mockUrlMap = {
+  getUsers: {
+    method: 'GET' as const,
+    url: '/users',
+  },
+  '/users': {
+    method: 'GET' as const,
+    url: '/users',
+  },
+}
+
+const mockInterfaceContent = 'export interface Test {}'
+
+beforeEach(() => {
+  mockCreateTmpDir = spyOn(utils, 'createTmpDir').mockReturnValue('df')
+  mockReadOpenapi = spyOn(utils, 'readOpenapi').mockReturnValue(
+    mockSchema as never,
+  )
+  mockWriteInterface = spyOn(utils, 'writeInterface').mockImplementation(
+    () => {},
+  )
+  mockCreateTmpDirAsync = spyOn(utils, 'createTmpDirAsync').mockResolvedValue(
+    'df',
+  )
+  mockReadOpenapiAsync = spyOn(utils, 'readOpenapiAsync').mockResolvedValue(
+    mockSchema as never,
+  )
+  mockWriteInterfaceAsync = spyOn(
+    utils,
+    'writeInterfaceAsync',
+  ).mockResolvedValue(undefined)
+  mockCreateUrlMap = spyOn(generator, 'createUrlMap').mockReturnValue(
+    mockUrlMap as never,
+  )
+  mockGenerateInterface = spyOn(generator, 'generateInterface').mockReturnValue(
+    mockInterfaceContent,
+  )
+  mockCreateTmpDir.mockClear()
+  mockReadOpenapi.mockClear()
+  mockWriteInterface.mockClear()
+  mockCreateTmpDirAsync.mockClear()
+  mockReadOpenapiAsync.mockClear()
+  mockWriteInterfaceAsync.mockClear()
+  mockCreateUrlMap.mockClear()
+  mockGenerateInterface.mockClear()
+})
+
+test.each([
+  [{}, undefined],
+  [{ env: {} }, undefined],
+  [{}, { tempDir: 'custom-dir' }],
+  [{ env: {} }, { openapiFile: 'custom-openapi.json' }],
+] as const)('devupApi handles turbo mode: config=%s, options=%s', (config: NextConfig, options:
+  | DevupApiOptions
+  | undefined) => {
+  const originalEnv = process.env.TURBOPACK
+  process.env.TURBOPACK = '1'
+
+  try {
+    const result = devupApi(config, options)
+
+    expect(mockCreateTmpDir).toHaveBeenCalledWith(options?.tempDir)
+    expect(mockReadOpenapi).toHaveBeenCalledWith(options?.openapiFile)
+    expect(mockGenerateInterface).toHaveBeenCalledWith(
+      mockSchema,
+      options || {},
+    )
+    expect(mockWriteInterface).toHaveBeenCalledWith(
+      join('df', 'api.d.ts'),
+      mockInterfaceContent,
+    )
+    expect(mockCreateUrlMap).toHaveBeenCalledWith(mockSchema, options || {})
+    expect(result.env).toEqual({
+      DEVUP_API_URL_MAP: JSON.stringify(mockUrlMap),
+    })
+    expect(result).toBe(config)
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi handles turbo mode with existing env', () => {
+  const originalEnv = process.env.TURBOPACK
+  process.env.TURBOPACK = '1'
+
+  try {
+    const config: NextConfig = {
+      env: {
+        EXISTING_VAR: 'value',
+      },
+    }
+    const result = devupApi(config)
+
+    expect(result.env).toEqual({
+      EXISTING_VAR: 'value',
+      DEVUP_API_URL_MAP: JSON.stringify(mockUrlMap),
+    })
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi handles turbo mode with TURBOPACK=auto', () => {
+  const originalEnv = process.env.TURBOPACK
+  process.env.TURBOPACK = 'auto'
+
+  try {
+    const config: NextConfig = {}
+    const result = devupApi(config)
+
+    expect(mockCreateTmpDir).toHaveBeenCalled()
+    expect(result.env).toEqual({
+      DEVUP_API_URL_MAP: JSON.stringify(mockUrlMap),
+    })
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test.each([
+  [{}, undefined],
+  [{ webpack: undefined }, undefined],
+  [{}, { tempDir: 'custom-dir' }],
+  [{ webpack: undefined }, { openapiFile: 'custom-openapi.json' }],
+] as const)('devupApi handles webpack mode: config=%s, options=%s', (config: NextConfig, options:
+  | DevupApiOptions
+  | undefined) => {
+  const originalEnv = process.env.TURBOPACK
+  delete process.env.TURBOPACK
+
+  try {
+    const result = devupApi(config, options)
+
+    expect(result.webpack).toBeDefined()
+    expect(typeof result.webpack).toBe('function')
+    expect(result).toBe(config)
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi handles webpack mode with existing webpack function', () => {
+  const originalEnv = process.env.TURBOPACK
+  delete process.env.TURBOPACK
+
+  try {
+    const existingWebpack = mock(() => ({}))
+    const config: NextConfig = {
+      webpack: existingWebpack as never,
+    }
+    const result = devupApi(config)
+
+    expect(result.webpack).toBeDefined()
+    expect(typeof result.webpack).toBe('function')
+    expect(result.webpack).not.toBe(existingWebpack)
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi webpack function adds plugin to config', () => {
+  const originalEnv = process.env.TURBOPACK
+  delete process.env.TURBOPACK
+
+  try {
+    const config: NextConfig = {}
+    const result = devupApi(config)
+
+    const webpackConfig = {
+      plugins: [],
+    }
+    const webpackOptions = {}
+    const webpackResult = result.webpack?.(
+      webpackConfig as never,
+      webpackOptions as never,
+    )
+
+    expect(webpackConfig.plugins).toHaveLength(1)
+    expect(webpackConfig.plugins[0]).toBeInstanceOf(devupApiWebpackPlugin)
+    expect(webpackResult).toBe(webpackConfig)
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi webpack function calls existing webpack function', () => {
+  const originalEnv = process.env.TURBOPACK
+  delete process.env.TURBOPACK
+
+  try {
+    const existingWebpack = mock(() => ({ modified: true }))
+    const config: NextConfig = {
+      webpack: existingWebpack as never,
+    }
+    const result = devupApi(config)
+
+    const webpackConfig = {
+      plugins: [],
+    }
+    const webpackOptions = {}
+    const webpackResult = result.webpack?.(
+      webpackConfig as never,
+      webpackOptions as never,
+    )
+
+    expect(existingWebpack).toHaveBeenCalledWith(webpackConfig, webpackOptions)
+    expect(webpackResult).toEqual({ modified: true })
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi handles null urlMap in turbo mode', () => {
+  const originalEnv = process.env.TURBOPACK
+  process.env.TURBOPACK = '1'
+  mockCreateUrlMap.mockReturnValueOnce(null as never)
+
+  try {
+    const config: NextConfig = {}
+    const result = devupApi(config)
+
+    expect(result.env).toEqual({
+      DEVUP_API_URL_MAP: JSON.stringify(null),
+    })
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})
+
+test('devupApi handles undefined urlMap in turbo mode', () => {
+  const originalEnv = process.env.TURBOPACK
+  process.env.TURBOPACK = '1'
+  mockCreateUrlMap.mockReturnValueOnce(undefined as never)
+
+  try {
+    const config: NextConfig = {}
+    const result = devupApi(config)
+
+    expect(result.env).toEqual({
+      DEVUP_API_URL_MAP: JSON.stringify(undefined),
+    })
+  } finally {
+    process.env.TURBOPACK = originalEnv
+  }
+})

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './plugin'
+export { devupApi as default } from './plugin'

package/src/plugin.ts

@@ -0,0 +1,38 @@
+import { join } from 'node:path'
+import type { DevupApiOptions } from '@devup-api/core'
+import { createUrlMap, generateInterface } from '@devup-api/generator'
+import { createTmpDir, readOpenapi, writeInterface } from '@devup-api/utils'
+import { devupApiWebpackPlugin } from '@devup-api/webpack-plugin'
+import type { NextConfig } from 'next'
+
+export function devupApi(
+  config: NextConfig,
+  options: DevupApiOptions = {},
+): NextConfig {
+  const isTurbo =
+    process.env.TURBOPACK === '1' || process.env.TURBOPACK === 'auto'
+  if (isTurbo) {
+    const tempDir = createTmpDir(options?.tempDir)
+    const schema = readOpenapi(options?.openapiFile)
+
+    writeInterface(
+      join(tempDir, 'api.d.ts'),
+      generateInterface(schema, options),
+    )
+    // Create urlMap and set environment variable
+    const urlMap = createUrlMap(schema, options)
+    config.env ??= {}
+    Object.assign(config.env, {
+      DEVUP_API_URL_MAP: JSON.stringify(urlMap),
+    })
+    return config
+  }
+
+  const webpack = config.webpack
+  config.webpack = (config, _options) => {
+    config.plugins.push(new devupApiWebpackPlugin(options))
+    if (typeof webpack === 'function') return webpack(config, _options)
+    return config
+  }
+  return config
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": true,
+    "emitDeclarationOnly": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}