@devup-api/webpack-plugin 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# @devup-api/webpack-plugin
+
+devup API plugin for Webpack
+
+## Installation
+
+```bash
+npm install @devup-api/webpack-plugin
+```
+
+## Usage
+
+```typescript
+import devupApiWebpackPlugin from '@devup-api/webpack-plugin';
+import webpack from 'webpack';
+
+const config: webpack.Configuration = {
+  plugins: [
+    new devupApiWebpackPlugin({
+      // 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:F,getOwnPropertyNames:Q,getOwnPropertyDescriptor:R}=Object,S=Object.prototype.hasOwnProperty;var K=new WeakMap,V=(x)=>{var W=K.get(x),q;if(W)return W;if(W=F({},"__esModule",{value:!0}),x&&typeof x==="object"||typeof x==="function")Q(x).map((z)=>!S.call(W,z)&&F(W,z,{get:()=>x[z],enumerable:!(q=R(x,z))||q.enumerable}));return K.set(x,W),W};var X=(x,W)=>{for(var q in W)F(x,q,{get:W[q],enumerable:!0,configurable:!0,set:(z)=>W[q]=()=>z})};var Y={};X(Y,{devupApiWebpackPlugin:()=>G,default:()=>G});module.exports=V(Y);var L=require("node:path"),C=require("@devup-api/generator"),B=require("@devup-api/utils"),N=require("webpack");class G{options;initialized=!1;constructor(x){this.options=x||{}}apply(x){x.hooks.beforeCompile.tapAsync("devup-api",async(W,q)=>{if(this.initialized){q();return}try{this.initialized=!0;let z=await B.createTmpDirAsync(this.options?.tempDir),H=await B.readOpenapiAsync(this.options?.openapiFile);await B.writeInterfaceAsync(L.join(z,"api.d.ts"),C.generateInterface(H,this.options));let J=C.createUrlMap(H,this.options),E={};if(J)E["process.env.DEVUP_API_URL_MAP"]=JSON.stringify(JSON.stringify(J));if(Object.keys(E).length>0)new N.DefinePlugin(E).apply(x);q()}catch(z){this.initialized=!1,q(z)}})}}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin';
+export { devupApiWebpackPlugin 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,qBAAqB,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1 @@
+import{join as F}from"node:path";import{createUrlMap as G,generateInterface as H}from"@devup-api/generator";import{createTmpDirAsync as J,readOpenapiAsync as K,writeInterfaceAsync as L}from"@devup-api/utils";import{DefinePlugin as N}from"webpack";class E{options;initialized=!1;constructor(x){this.options=x||{}}apply(x){x.hooks.beforeCompile.tapAsync("devup-api",async(Q,W)=>{if(this.initialized){W();return}try{this.initialized=!0;let q=await J(this.options?.tempDir),B=await K(this.options?.openapiFile);await L(F(q,"api.d.ts"),H(B,this.options));let C=G(B,this.options),z={};if(C)z["process.env.DEVUP_API_URL_MAP"]=JSON.stringify(JSON.stringify(C));if(Object.keys(z).length>0)new N(z).apply(x);W()}catch(q){this.initialized=!1,W(q)}})}}export{E as devupApiWebpackPlugin,E as default};

package/dist/plugin.d.ts

@@ -0,0 +1,9 @@
+import type { DevupApiOptions } from '@devup-api/core';
+import type { Compiler } from 'webpack';
+export declare class devupApiWebpackPlugin {
+    options: DevupApiOptions;
+    initialized: boolean;
+    constructor(options?: DevupApiOptions);
+    apply(compiler: Compiler): void;
+}
+//# 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;AAOtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGvC,qBAAa,qBAAqB;IAChC,OAAO,EAAE,eAAe,CAAA;IACxB,WAAW,UAAQ;gBAEP,OAAO,CAAC,EAAE,eAAe;IAIrC,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CA6ChC"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@devup-api/webpack-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"
+  },
+  "peerDependencies": {
+    "webpack": "*",
+    "@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({
+    devupApiWebpackPlugin: expect.any(Function),
+    default: expect.any(Function),
+  })
+})

package/src/__tests__/plugin.test.ts

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

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

package/src/plugin.ts

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

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