@devup-api/rsbuild-plugin 0.1.0

package/README.md

@@ -0,0 +1,24 @@
+# @devup-api/rsbuild-plugin
+
+devup API plugin for Rsbuild
+
+## Installation
+
+```bash
+npm install @devup-api/rsbuild-plugin
+```
+
+## Usage
+
+```typescript
+import devupApiRsbuildPlugin from '@devup-api/rsbuild-plugin';
+import { defineConfig } from '@rsbuild/core';
+
+export default defineConfig({
+  plugins: [
+    devupApiRsbuildPlugin({
+      // 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:E,getOwnPropertyNames:K,getOwnPropertyDescriptor:L}=Object,N=Object.prototype.hasOwnProperty;var G=new WeakMap,Q=(x)=>{var P=G.get(x),k;if(P)return P;if(P=E({},"__esModule",{value:!0}),x&&typeof x==="object"||typeof x==="function")K(x).map((R)=>!N.call(P,R)&&E(P,R,{get:()=>x[R],enumerable:!(k=L(x,R))||k.enumerable}));return G.set(x,P),P};var S=(x,P)=>{for(var k in P)E(x,k,{get:P[k],enumerable:!0,configurable:!0,set:(R)=>P[k]=()=>R})};var V={};S(V,{devupApiRsbuildPlugin:()=>J,default:()=>J});module.exports=Q(V);var H=require("node:path"),B=require("@devup-api/generator"),q=require("@devup-api/utils");function J(x){return{name:"devup-api",async setup(P){let k=await q.createTmpDirAsync(x?.tempDir),R=await q.readOpenapiAsync(x?.openapiFile);await q.writeInterfaceAsync(H.join(k,"api.d.ts"),B.generateInterface(R,x));let F=B.createUrlMap(R,x);P.modifyRsbuildConfig((z)=>{if(z.source??={},z.source.define??={},F)z.source.define["process.env.DEVUP_API_URL_MAP"]=JSON.stringify(JSON.stringify(F));return z})}}}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin';
+export { devupApiRsbuildPlugin 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 B}from"node:path";import{createUrlMap as E,generateInterface as F}from"@devup-api/generator";import{createTmpDirAsync as G,readOpenapiAsync as H,writeInterfaceAsync as J}from"@devup-api/utils";function K(x){return{name:"devup-api",async setup(q){let z=await G(x?.tempDir),R=await H(x?.openapiFile);await J(B(z,"api.d.ts"),F(R,x));let k=E(R,x);q.modifyRsbuildConfig((P)=>{if(P.source??={},P.source.define??={},k)P.source.define["process.env.DEVUP_API_URL_MAP"]=JSON.stringify(JSON.stringify(k));return P})}}}export{K as devupApiRsbuildPlugin,K as default};

package/dist/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { DevupApiOptions } from '@devup-api/core';
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare function devupApiRsbuildPlugin(options?: DevupApiOptions): RsbuildPlugin;
+//# 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,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,wBAAgB,qBAAqB,CACnC,OAAO,CAAC,EAAE,eAAe,GACxB,aAAa,CA2Bf"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@devup-api/rsbuild-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": {
+    "@rsbuild/core": "*",
+    "@devup-api/core": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10",
+    "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({
+    devupApiRsbuildPlugin: expect.any(Function),
+    default: expect.any(Function),
+  })
+})

package/src/__tests__/plugin.test.ts

@@ -0,0 +1,228 @@
+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 { devupApiRsbuildPlugin } 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 createMockBuild = () => {
+  const modifyRsbuildConfigMock = mock(
+    (modifier: (config: unknown) => unknown) => {
+      const config = { source: { define: {} } }
+      return modifier(config)
+    },
+  )
+  return {
+    modifyRsbuildConfig: modifyRsbuildConfigMock,
+  }
+}
+
+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('devupApiRsbuildPlugin returns plugin with correct name', () => {
+  const plugin = devupApiRsbuildPlugin()
+  expect(plugin.name).toBe('devup-api')
+})
+
+test.each([
+  [undefined],
+  [{ tempDir: 'custom-dir' }],
+  [{ openapiFile: 'custom-openapi.json' }],
+  [
+    {
+      tempDir: 'custom-dir',
+      openapiFile: 'custom-openapi.json',
+      convertCase: 'snake' as const,
+    },
+  ],
+] as const)('devupApiRsbuildPlugin returns plugin with setup hook: %s', async (options:
+  | DevupApiOptions
+  | undefined) => {
+  const plugin = devupApiRsbuildPlugin(options)
+  expect(plugin.setup).toBeDefined()
+  expect(typeof plugin.setup).toBe('function')
+
+  const build = createMockBuild()
+  await plugin.setup?.(build as never)
+
+  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(build.modifyRsbuildConfig).toHaveBeenCalled()
+})
+
+test('devupApiRsbuildPlugin setup hook modifies config with urlMap', async () => {
+  const plugin = devupApiRsbuildPlugin()
+  const build = createMockBuild()
+  await plugin.setup?.(build as never)
+
+  const configModifier = (build.modifyRsbuildConfig as ReturnType<typeof mock>)
+    .mock.calls[0]?.[0] as (config: {
+    source?: { define?: Record<string, string> }
+  }) => unknown
+  const config = { source: { define: {} } }
+  const result = configModifier(config)
+
+  expect(result).toEqual({
+    source: {
+      define: {
+        'process.env.DEVUP_API_URL_MAP': JSON.stringify(
+          JSON.stringify(mockUrlMap),
+        ),
+      },
+    },
+  })
+})
+
+test('devupApiRsbuildPlugin setup hook handles config without source', async () => {
+  const plugin = devupApiRsbuildPlugin()
+  const build = createMockBuild()
+  await plugin.setup?.(build as never)
+
+  const configModifier = (build.modifyRsbuildConfig as ReturnType<typeof mock>)
+    .mock.calls[0]?.[0] as (config: Record<string, unknown>) => unknown
+  const config = {}
+  const result = configModifier(config)
+
+  expect(result).toEqual({
+    source: {
+      define: {
+        'process.env.DEVUP_API_URL_MAP': JSON.stringify(
+          JSON.stringify(mockUrlMap),
+        ),
+      },
+    },
+  })
+})
+
+test('devupApiRsbuildPlugin setup hook handles config without define', async () => {
+  const plugin = devupApiRsbuildPlugin()
+  const build = createMockBuild()
+  await plugin.setup?.(build as never)
+
+  const configModifier = (build.modifyRsbuildConfig as ReturnType<typeof mock>)
+    .mock.calls[0]?.[0] as (config: {
+    source?: Record<string, unknown>
+  }) => unknown
+  const config = { source: {} }
+  const result = configModifier(config)
+
+  expect(result).toEqual({
+    source: {
+      define: {
+        'process.env.DEVUP_API_URL_MAP': JSON.stringify(
+          JSON.stringify(mockUrlMap),
+        ),
+      },
+    },
+  })
+})
+
+test('devupApiRsbuildPlugin setup hook does not add urlMap when urlMap is null', async () => {
+  mockCreateUrlMap.mockReturnValueOnce(null as never)
+  const plugin = devupApiRsbuildPlugin()
+  const build = createMockBuild()
+  await plugin.setup?.(build as never)
+
+  const configModifier = (build.modifyRsbuildConfig as ReturnType<typeof mock>)
+    .mock.calls[0]?.[0] as (config: {
+    source?: { define?: Record<string, string> }
+  }) => unknown
+  const config = { source: { define: {} } }
+  const result = configModifier(config)
+
+  expect(result).toEqual({
+    source: {
+      define: {},
+    },
+  })
+})
+
+test('devupApiRsbuildPlugin setup hook does not add urlMap when urlMap is undefined', async () => {
+  mockCreateUrlMap.mockReturnValueOnce(undefined as never)
+  const plugin = devupApiRsbuildPlugin()
+  const build = createMockBuild()
+  await plugin.setup?.(build as never)
+
+  const configModifier = (build.modifyRsbuildConfig as ReturnType<typeof mock>)
+    .mock.calls[0]?.[0] as (config: {
+    source?: { define?: Record<string, string> }
+  }) => unknown
+  const config = { source: { define: {} } }
+  const result = configModifier(config)
+
+  expect(result).toEqual({
+    source: {
+      define: {},
+    },
+  })
+})

package/src/index.ts

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

package/src/plugin.ts

@@ -0,0 +1,40 @@
+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 { RsbuildPlugin } from '@rsbuild/core'
+
+export function devupApiRsbuildPlugin(
+  options?: DevupApiOptions,
+): RsbuildPlugin {
+  return {
+    name: 'devup-api',
+    async setup(build) {
+      const tempDir = await createTmpDirAsync(options?.tempDir)
+      const schema = await readOpenapiAsync(options?.openapiFile)
+
+      // Generate interface file
+      await writeInterfaceAsync(
+        join(tempDir, 'api.d.ts'),
+        generateInterface(schema, options),
+      )
+
+      // Create urlMap and set environment variable
+      const urlMap = createUrlMap(schema, options)
+
+      build.modifyRsbuildConfig((config) => {
+        config.source ??= {}
+        config.source.define ??= {}
+        if (urlMap) {
+          config.source.define['process.env.DEVUP_API_URL_MAP'] =
+            JSON.stringify(JSON.stringify(urlMap))
+        }
+        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"]
+}