swaggie 2.2.1 → 2.3.0

package/README.md

@@ -396,6 +396,21 @@ Sometimes an API spec marks a parameter as required, but your client handles it
 - `"optional"` — the parameter becomes optional regardless of what the spec says
 - `"required"` — the parameter is always required (generally better to just fix the spec)
 
+### Excluding Operations
+
+Use `exclude` to drop entire operations from the generated output by tag or `operationId` — without modifying the spec. Types used exclusively by excluded operations are pruned automatically. Both fields support `*` and `?` wildcards.
+
+```json
+{
+  "exclude": {
+    "tags": ["admin", "internal"],
+    "operationIds": ["deleteAccount", "admin*"]
+  }
+}
+```
+
+See the [full documentation](https://yhnavein.github.io/swaggie/guide/advanced#excluding-operations) for details and examples.
+
 ### Code Quality
 
 Swaggie's output is functional but not always perfectly formatted, since it uses a templating engine internally. It is strongly recommended to run the output through a formatter to ensure consistent style across regenerations.

package/dist/gen/genMocks.js

@@ -48,10 +48,7 @@ const MOCK_FILE_HEADER = `\
   const template = options.template;
 
   if (template === 'ng1') {
-    throw new Error(
-      'Mock generation is not supported for the "ng1" template. ' +
-        'Use "ng2", "axios", "fetch", "xior", "swr", or "tsq" instead.'
-    );
+    throw new Error('Mock generation is not supported for the "ng1" template');
   }
 
   const isNg2 = template === 'ng2';
@@ -254,28 +251,34 @@ interface MockSWRReturn {
   data: unknown;
   /** Whether to return a loading state (default: false) */
   isLoading?: boolean;
+  /** Whether to return a validating state (default: false) */
+  isValidating?: boolean;
   /** Whether to return an error (default: undefined) */
   error?: Error | undefined | null;
+  /** The mutate function to return (default: empty mock) */
+  mutate?: KeyedMutator<any>;
 }
 
 interface MockSWRMutationReturn {
   /** The data to return from the mock */
-  data: unknown;
+  data?: unknown;
   /** Whether to return a mutating state (default: false) */
   isMutating?: boolean;
   /** Whether to return an error (default: undefined) */
   error?: Error | undefined | null;
+  /** The trigger function to return (default: empty mock) */
+  trigger?: (...args: unknown[]) => Promise<unknown>;
+  /** The reset function to return (default: empty mock) */
+  reset?: () => void;
 }
 
 /** Augments a spy with a \`mockSWR\` shorthand for useSWR query hooks. */
 function withMockSWR<Fn extends (...args: never[]) => unknown>(spy: ${ref}.SpiedFunction<Fn>) {
   return Object.assign(spy, {
-    mockSWR({ data, isLoading, error }: MockSWRReturn) {
+    mockSWR({ ...rest }: MockSWRReturn) {
       spy.mockReturnValue({
         ...defaultSWRReturn,
-        data,
-        isLoading: isLoading ?? false,
-        error: error ?? undefined,
+        ...rest,
       } as ReturnType<Fn>);
     },
   });
@@ -284,17 +287,10 @@ function withMockSWR<Fn extends (...args: never[]) => unknown>(spy: ${ref}.Spied
 /** Augments a spy with a \`mockSWRMutation\` shorthand for useSWRMutation hooks. */
 function withMockSWRMutation<Fn extends (...args: never[]) => unknown>(spy: ${ref}.SpiedFunction<Fn>) {
   return Object.assign(spy, {
-    mockSWRMutation({
-      data,
-      isMutating,
-      error,
-    }: MockSWRMutationReturn) {
+    mockSWRMutation({ ...rest }: MockSWRMutationReturn) {
       spy.mockReturnValue({
         ...defaultSWRMutationReturn,
-        trigger: ${ref}.fn(() => Promise.resolve(undefined)),
-        isMutating: isMutating ?? false,
-        error: error ?? undefined,
-        data,
+        ...rest,
       } as ReturnType<Fn>);
     },
   });

package/dist/gen/genOperations.js

@@ -255,6 +255,18 @@ function prepareClient(
     ops = ops.filter((op) => !op.deprecated);
   }
 
+  if (_optionalChain([options, 'access', _2 => _2.exclude, 'optionalAccess', _3 => _3.tags, 'optionalAccess', _4 => _4.length])) {
+    ops = ops.filter(
+      (op) => !_optionalChain([op, 'access', _5 => _5.tags, 'optionalAccess', _6 => _6.some, 'call', _7 => _7((t) => options.exclude.tags.some((p) => matchesPattern(t, p)))])
+    );
+  }
+
+  if (_optionalChain([options, 'access', _8 => _8.exclude, 'optionalAccess', _9 => _9.operationIds, 'optionalAccess', _10 => _10.length])) {
+    ops = ops.filter(
+      (op) => !options.exclude.operationIds.some((p) => matchesPattern(_nullishCoalesce(op.operationId, () => ( '')), p))
+    );
+  }
+
   return ops.map((op) => {
     const operationContext = `${op.method.toUpperCase()} ${op.path} (${op.operationId || 'unknown operationId'})`;
 
@@ -295,9 +307,9 @@ function prepareClient(
 
       const headers = getParams(op.parameters , options, ['header']);
       // Some libraries need explicit Content-Type for request bodies.
-      if (_optionalChain([body, 'optionalAccess', _2 => _2.contentType]) === 'urlencoded') {
+      if (_optionalChain([body, 'optionalAccess', _11 => _11.contentType]) === 'urlencoded') {
         upsertFixedHeader(headers, 'Content-Type', 'application/x-www-form-urlencoded');
-      } else if (_optionalChain([body, 'optionalAccess', _3 => _3.contentType]) === 'json' && _templateValidator.getL1Template.call(void 0, options.template) === 'fetch') {
+      } else if (_optionalChain([body, 'optionalAccess', _12 => _12.contentType]) === 'json' && _templateValidator.getL1Template.call(void 0, options.template) === 'fetch') {
         upsertFixedHeader(headers, 'Content-Type', 'application/json');
       }
 
@@ -485,10 +497,10 @@ function prepareUrl(path) {
       type: _swagger.getParameterType.call(void 0, p, options),
       optional: p.required === undefined || p.required === null ? true : !p.required,
       original: p,
-      jsDoc: _optionalChain([p, 'access', _4 => _4.description, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]),
+      jsDoc: _optionalChain([p, 'access', _13 => _13.description, 'optionalAccess', _14 => _14.trim, 'call', _15 => _15()]),
     }));
 
-  if (_optionalChain([options, 'access', _7 => _7.modifiers, 'optionalAccess', _8 => _8.parameters])) {
+  if (_optionalChain([options, 'access', _16 => _16.modifiers, 'optionalAccess', _17 => _17.parameters])) {
     for (const [name, modifier] of Object.entries(options.modifiers.parameters)) {
       const paramIndex = result.findIndex(
         (p) => p.original.in !== 'path' && (p.originalName === name || p.name === name)
@@ -539,7 +551,7 @@ function getRequestBody(
   let reqBody;
   if ('$ref' in rawReqBody) {
     const refName = rawReqBody.$ref.replace('#/components/requestBodies/', '');
-    const resolved = _optionalChain([components, 'optionalAccess', _9 => _9.requestBodies, 'optionalAccess', _10 => _10[refName]]);
+    const resolved = _optionalChain([components, 'optionalAccess', _18 => _18.requestBodies, 'optionalAccess', _19 => _19[refName]]);
     if (!resolved || '$ref' in resolved) {
       console.error(`RequestBody $ref '${rawReqBody.$ref}' not found in components/requestBodies`);
       return null;
@@ -673,6 +685,23 @@ function getL1HttpTypeImport(template) {
   }
 }
 
+/**
+ * Matches a value against a pattern that may contain `*` (any sequence of
+ * characters) or `?` (any single character). Falls back to exact equality for
+ * patterns that contain neither wildcard (fast path).
+ */
+ function matchesPattern(value, pattern) {
+  if (!pattern.includes('*') && !pattern.includes('?')) {
+    return value === pattern;
+  }
+  const regex = new RegExp(
+    '^' +
+      pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') +
+      '$'
+  );
+  return regex.test(value);
+} exports.matchesPattern = matchesPattern;
+
 function upsertFixedHeader(headers, headerName, value) {
   const headerIndex = headers.findIndex(
     (header) => header.originalName.toLowerCase() === headerName.toLowerCase()

package/dist/index.js

@@ -10,6 +10,7 @@ var _gen = require('./gen'); var _gen2 = _interopRequireDefault(_gen);
 
 
 
+
 var _utils = require('./utils');
 var _templateValidator = require('./utils/templateValidator');
 var _swagger = require('./swagger');
@@ -86,6 +87,7 @@ function verifyOptions(options) {
       );
     }
   }
+  verifyExcludeOptions(options.exclude);
 }
 
 /**
@@ -126,6 +128,43 @@ function verifyEntryOptions(opts) {
       );
     }
   }
+  verifyExcludeOptions(opts.exclude);
+}
+
+/**
+ * Returns true when a pattern looks like a regex (starts with `/` or contains
+ * regex-specific metacharacters that are not our supported wildcards).
+ * Our supported wildcards are `*` and `?` only.
+ */
+function isRegexPattern(pattern) {
+  if (pattern.startsWith('/')) {
+    return true;
+  }
+  // Characters that are regex metacharacters but are NOT our supported wildcards
+  const regexOnlyChars = /[\\^$.|+()[\]{}]/;
+  return regexOnlyChars.test(pattern);
+}
+
+/**
+ * Throws if any pattern in `exclude.tags` or `exclude.operationIds` looks like
+ * a regex. Only plain strings and * / ? wildcards are supported.
+ */
+function verifyExcludeOptions(exclude) {
+  if (!exclude) {
+    return;
+  }
+  const allPatterns = [
+    ...(_nullishCoalesce(exclude.tags, () => ( []))).map((p) => ['exclude.tags', p]),
+    ...(_nullishCoalesce(exclude.operationIds, () => ( []))).map((p) => ['exclude.operationIds', p]),
+  ];
+  for (const [field, pattern] of allPatterns) {
+    if (isRegexPattern(pattern)) {
+      throw new Error(
+        `Invalid pattern "${pattern}" in ${field}: regex patterns are not supported. ` +
+          'Use plain strings or wildcard patterns with * and ? only.'
+      );
+    }
+  }
 }
 
 /**

package/dist/types.d.ts

@@ -4,6 +4,18 @@ interface QueryParamsSerializationOptions {
     arrayFormat?: ArrayFormat;
     queryParamsAsObject?: boolean | number;
 }
+export interface ExcludeOptions {
+    /**
+     * Exclude operations whose first tag matches any of these values.
+     * Supports * (any sequence of characters) and ? (any single character) wildcards.
+     */
+    tags?: string[];
+    /**
+     * Exclude operations whose operationId matches any of these values.
+     * Supports * (any sequence of characters) and ? (any single character) wildcards.
+     */
+    operationIds?: string[];
+}
 export interface ClientOptions {
     /**
      * Path or URL to the Swagger specification file (JSON or YAML).
@@ -106,6 +118,8 @@ export interface ClientOptions {
             [key: string]: 'optional' | 'required' | 'ignore';
         };
     };
+    /** Excludes specific operations from code generation by tag or operationId */
+    exclude?: ExcludeOptions;
 }
 export interface CliOptions extends Omit<FullAppOptions, 'enumNamesStyle'> {
     allowDots?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swaggie",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Generate a fully typed TypeScript API client from your OpenAPI 3 spec",
   "author": {
     "name": "Piotr Dabrowski",