@devup-api/next-plugin 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@devup-api/next-plugin",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": {
@@ -9,6 +10,9 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "files": [
+    "dist"
+  ],
   "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"
   },
@@ -16,10 +20,10 @@
     "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"
+    "@devup-api/utils": "0.1.1",
+    "@devup-api/core": "0.1.1",
+    "@devup-api/generator": "0.1.1",
+    "@devup-api/webpack-plugin": "0.1.1"
   },
   "peerDependencies": {
     "next": "*",

package/src/__tests__/index.test.ts

@@ -1,9 +0,0 @@
-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

@@ -1,286 +0,0 @@
-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

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

package/src/plugin.ts

@@ -1,38 +0,0 @@
-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

@@ -1,34 +0,0 @@
-{
-  "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"]
-}