@devup-api/webpack-plugin 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@devup-api/webpack-plugin",
-  "version": "0.1.0",
+  "version": "0.1.2",
+  "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,9 +20,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@devup-api/utils": "0.1.0",
-    "@devup-api/core": "0.1.0",
-    "@devup-api/generator": "0.1.0"
+    "@devup-api/utils": "0.1.2",
+    "@devup-api/core": "0.1.2",
+    "@devup-api/generator": "0.1.2"
   },
   "peerDependencies": {
     "webpack": "*",

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

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

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

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

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

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

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

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

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({
-    devupApiWebpackPlugin: expect.any(Function),
-    default: expect.any(Function),
-  })
-})

package/src/__tests__/plugin.test.ts

@@ -1,263 +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 type { Compiler } from 'webpack'
-import { DefinePlugin } from 'webpack'
-import { devupApiWebpackPlugin } from '../plugin'
-
-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 {}'
-
-const createMockCompiler = (): Compiler & {
-  _storedCallback?: (params: unknown, cb: (error?: Error) => void) => void
-} => {
-  const storedCallback: {
-    callback?: (params: unknown, cb: (error?: Error) => void) => void
-  } = {}
-  const tapAsyncMock = mock(
-    (
-      _name: string,
-      callback: (params: unknown, cb: (error?: Error) => void) => void,
-    ) => {
-      storedCallback.callback = callback
-    },
-  )
-  const hooks = {
-    beforeCompile: {
-      tapAsync: tapAsyncMock,
-    },
-  }
-  const compiler = {
-    hooks,
-  } as unknown as Compiler & {
-    _storedCallback?: (params: unknown, cb: (error?: Error) => void) => void
-  }
-  Object.defineProperty(compiler, '_storedCallback', {
-    get() {
-      return storedCallback.callback
-    },
-    enumerable: true,
-    configurable: true,
-  })
-  return compiler
-}
-
-beforeEach(() => {
-  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,
-  )
-  mockCreateTmpDirAsync.mockClear()
-  mockReadOpenapiAsync.mockClear()
-  mockWriteInterfaceAsync.mockClear()
-  mockCreateUrlMap.mockClear()
-  mockGenerateInterface.mockClear()
-})
-
-test('devupApiWebpackPlugin constructor initializes with default options', () => {
-  const plugin = new devupApiWebpackPlugin()
-  expect(plugin.options).toEqual({})
-  expect(plugin.initialized).toBe(false)
-})
-
-test.each([
-  [{ tempDir: 'custom-dir' }],
-  [{ openapiFile: 'custom-openapi.json' }],
-  [
-    {
-      tempDir: 'custom-dir',
-      openapiFile: 'custom-openapi.json',
-      convertCase: 'snake' as const,
-    },
-  ],
-] as const)('devupApiWebpackPlugin constructor initializes with options: %s', (options: DevupApiOptions) => {
-  const plugin = new devupApiWebpackPlugin(options)
-  expect(plugin.options).toEqual(options)
-  expect(plugin.initialized).toBe(false)
-})
-
-test('devupApiWebpackPlugin apply method registers beforeCompile hook', () => {
-  const plugin = new devupApiWebpackPlugin()
-  const compiler = createMockCompiler()
-  plugin.apply(compiler)
-  expect(compiler.hooks.beforeCompile.tapAsync).toHaveBeenCalledWith(
-    'devup-api',
-    expect.any(Function),
-  )
-  expect(compiler._storedCallback).toBeDefined()
-})
-
-test.each([
-  [undefined],
-  [{ tempDir: 'custom-dir' }],
-  [{ openapiFile: 'custom-openapi.json' }],
-  [
-    {
-      tempDir: 'custom-dir',
-      openapiFile: 'custom-openapi.json',
-      convertCase: 'pascal' as const,
-    },
-  ],
-] as const)('devupApiWebpackPlugin beforeCompile hook executes correctly: %s', async (options:
-  | DevupApiOptions
-  | undefined) => {
-  const plugin = new devupApiWebpackPlugin(options)
-  const compiler = createMockCompiler()
-  const definePluginApplySpy = spyOn(
-    DefinePlugin.prototype,
-    'apply',
-  ).mockImplementation(() => {})
-  plugin.apply(compiler)
-
-  const callback = compiler._storedCallback
-  expect(callback).toBeDefined()
-
-  const mockCallback = mock(() => {})
-  await callback?.(null, mockCallback)
-
-  expect(mockCreateTmpDirAsync).toHaveBeenCalledWith(options?.tempDir)
-  expect(mockReadOpenapiAsync).toHaveBeenCalledWith(options?.openapiFile)
-  expect(mockGenerateInterface).toHaveBeenCalledWith(mockSchema, options || {})
-  expect(mockWriteInterfaceAsync).toHaveBeenCalledWith(
-    join('df', 'api.d.ts'),
-    mockInterfaceContent,
-  )
-  expect(mockCreateUrlMap).toHaveBeenCalledWith(mockSchema, options || {})
-  expect(definePluginApplySpy).toHaveBeenCalledWith(compiler)
-  expect(mockCallback).toHaveBeenCalled()
-  expect(plugin.initialized).toBe(true)
-  definePluginApplySpy.mockRestore()
-})
-
-test('devupApiWebpackPlugin beforeCompile hook does not add DefinePlugin when urlMap is null', async () => {
-  mockCreateUrlMap.mockReturnValueOnce(null as never)
-  const plugin = new devupApiWebpackPlugin()
-  const compiler = createMockCompiler()
-  const definePluginApplySpy = spyOn(
-    DefinePlugin.prototype,
-    'apply',
-  ).mockImplementation(() => {})
-  plugin.apply(compiler)
-
-  const callback = compiler._storedCallback
-
-  const mockCallback = mock(() => {})
-  await callback?.(null, mockCallback)
-
-  expect(definePluginApplySpy).not.toHaveBeenCalled()
-  expect(mockCallback).toHaveBeenCalled()
-  definePluginApplySpy.mockRestore()
-})
-
-test('devupApiWebpackPlugin beforeCompile hook does not add DefinePlugin when urlMap is undefined', async () => {
-  mockCreateUrlMap.mockReturnValueOnce(undefined as never)
-  const plugin = new devupApiWebpackPlugin()
-  const compiler = createMockCompiler()
-  const definePluginApplySpy = spyOn(
-    DefinePlugin.prototype,
-    'apply',
-  ).mockImplementation(() => {})
-  plugin.apply(compiler)
-
-  const callback = compiler._storedCallback
-
-  const mockCallback = mock(() => {})
-  await callback?.(null, mockCallback)
-
-  expect(definePluginApplySpy).not.toHaveBeenCalled()
-  expect(mockCallback).toHaveBeenCalled()
-  definePluginApplySpy.mockRestore()
-})
-
-test('devupApiWebpackPlugin beforeCompile hook only runs once when called multiple times', async () => {
-  const plugin = new devupApiWebpackPlugin()
-  const compiler = createMockCompiler()
-  plugin.apply(compiler)
-
-  const callback = compiler._storedCallback
-
-  const mockCallback1 = mock(() => {})
-  const mockCallback2 = mock(() => {})
-
-  await Promise.all([
-    callback?.(null, mockCallback1),
-    callback?.(null, mockCallback2),
-  ])
-
-  expect(mockCreateTmpDirAsync).toHaveBeenCalledTimes(1)
-  expect(mockReadOpenapiAsync).toHaveBeenCalledTimes(1)
-  expect(mockGenerateInterface).toHaveBeenCalledTimes(1)
-  expect(mockWriteInterfaceAsync).toHaveBeenCalledTimes(1)
-  expect(mockCreateUrlMap).toHaveBeenCalledTimes(1)
-  expect(mockCallback1).toHaveBeenCalled()
-  expect(mockCallback2).toHaveBeenCalled()
-})
-
-test('devupApiWebpackPlugin beforeCompile hook handles errors correctly', async () => {
-  const error = new Error('Test error')
-  mockCreateTmpDirAsync.mockRejectedValueOnce(error)
-  const plugin = new devupApiWebpackPlugin()
-  const compiler = createMockCompiler()
-  plugin.apply(compiler)
-
-  const callback = compiler._storedCallback
-
-  const mockCallback = mock(() => {})
-  await callback?.(null, mockCallback)
-
-  expect(mockCallback).toHaveBeenCalledWith(error)
-  expect(plugin.initialized).toBe(false)
-})

package/src/index.ts

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

package/src/plugin.ts

@@ -1,65 +0,0 @@
-import { join } from 'node:path'
-import type { DevupApiOptions } from '@devup-api/core'
-import { createUrlMap, generateInterface } from '@devup-api/generator'
-import {
-  createTmpDirAsync,
-  readOpenapiAsync,
-  writeInterfaceAsync,
-} from '@devup-api/utils'
-import type { Compiler } from 'webpack'
-import { DefinePlugin } from 'webpack'
-
-export class devupApiWebpackPlugin {
-  options: DevupApiOptions
-  initialized = false
-
-  constructor(options?: DevupApiOptions) {
-    this.options = options || {}
-  }
-
-  apply(compiler: Compiler): void {
-    // Perform async operations before compilation
-    compiler.hooks.beforeCompile.tapAsync(
-      'devup-api',
-      async (_params, callback) => {
-        // Guard: only run once
-        if (this.initialized) {
-          callback()
-          return
-        }
-
-        try {
-          this.initialized = true
-
-          const tempDir = await createTmpDirAsync(this.options?.tempDir)
-          const schema = await readOpenapiAsync(this.options?.openapiFile)
-
-          // Generate interface file
-          await writeInterfaceAsync(
-            join(tempDir, 'api.d.ts'),
-            generateInterface(schema, this.options),
-          )
-
-          // Create urlMap and set environment variable
-          const urlMap = createUrlMap(schema, this.options)
-          const define: Record<string, string> = {}
-          if (urlMap) {
-            define['process.env.DEVUP_API_URL_MAP'] = JSON.stringify(
-              JSON.stringify(urlMap),
-            )
-          }
-
-          // Add DefinePlugin to webpack configuration
-          if (Object.keys(define).length > 0) {
-            new DefinePlugin(define).apply(compiler)
-          }
-
-          callback()
-        } catch (error) {
-          this.initialized = false
-          callback(error as Error)
-        }
-      },
-    )
-  }
-}

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"]
-}