chore: cleanup

Author: mrlubos

packages/openapi-ts/src/plugins/@hey-api/typescript/operation.ts

@@ -9,7 +9,8 @@ import { schemaToType } from './plugin';
 import { typesId } from './ref';
 import type { HeyApiTypeScriptPlugin, PluginState } from './types';
 
-const irParametersToIrSchema = ({
+// TODO: exported just for @pinia/colada, remove export once that plugin does not depend on it
+export const irParametersToIrSchema = ({
   parameters,
 }: {
   parameters: Record<string, IR.ParameterObject>;

packages/openapi-ts/src/plugins/@hey-api/typescript/plugin.ts

@@ -482,281 +482,6 @@ const schemaTypeToIdentifier = ({
   }
 };
 
-export const irParametersToIrSchema = ({
-  parameters,
-}: {
-  parameters: Record<string, IR.ParameterObject>;
-}): IR.SchemaObject => {
-  const irSchema: IR.SchemaObject = {
-    type: 'object',
-  };
-
-  if (parameters) {
-    const properties: Record<string, IR.SchemaObject> = {};
-    const required: Array<string> = [];
-
-    for (const name in parameters) {
-      const parameter = parameters[name]!;
-
-      properties[name] = deduplicateSchema({
-        schema: parameter.schema,
-      });
-
-      if (parameter.required) {
-        required.push(name);
-      }
-    }
-
-    irSchema.properties = properties;
-
-    if (required.length) {
-      irSchema.required = required;
-    }
-  }
-
-  return irSchema;
-};
-
-const operationToDataType = ({
-  context,
-  operation,
-  plugin,
-}: {
-  context: IR.Context;
-  operation: IR.OperationObject;
-  plugin: Plugin.Instance<Config>;
-}) => {
-  const file = context.file({ id: typesId })!;
-  const data: IR.SchemaObject = {
-    type: 'object',
-  };
-  const dataRequired: Array<string> = [];
-
-  if (!data.properties) {
-    data.properties = {};
-  }
-
-  if (operation.body) {
-    data.properties.body = operation.body.schema;
-
-    if (operation.body.required) {
-      dataRequired.push('body');
-    }
-  } else {
-    data.properties.body = {
-      type: 'never',
-    };
-  }
-
-  // TODO: parser - handle cookie parameters
-
-  // do not set headers to never so we can always pass arbitrary values
-  if (operation.parameters?.header) {
-    data.properties.headers = irParametersToIrSchema({
-      parameters: operation.parameters.header,
-    });
-
-    if (data.properties.headers.required) {
-      dataRequired.push('headers');
-    }
-  }
-
-  if (operation.parameters?.path) {
-    data.properties.path = irParametersToIrSchema({
-      parameters: operation.parameters.path,
-    });
-
-    if (data.properties.path.required) {
-      dataRequired.push('path');
-    }
-  } else {
-    data.properties.path = {
-      type: 'never',
-    };
-  }
-
-  if (operation.parameters?.query) {
-    data.properties.query = irParametersToIrSchema({
-      parameters: operation.parameters.query,
-    });
-
-    if (data.properties.query.required) {
-      dataRequired.push('query');
-    }
-  } else {
-    data.properties.query = {
-      type: 'never',
-    };
-  }
-
-  data.properties.url = {
-    const: operation.path,
-    type: 'string',
-  };
-  dataRequired.push('url');
-
-  data.required = dataRequired;
-
-  const identifier = file.identifier({
-    $ref: operationIrRef({ id: operation.id, type: 'data' }),
-    create: true,
-    namespace: 'type',
-  });
-  const type = schemaToType({
-    context,
-    plugin,
-    schema: data,
-    state:
-      plugin.readOnlyWriteOnlyBehavior === 'off'
-        ? undefined
-        : {
-            accessScope: 'write',
-          },
-  });
-
-  if (type) {
-    const node = compiler.typeAliasDeclaration({
-      exportType: true,
-      name: identifier.name || '',
-      type,
-    });
-    file.add(node);
-  }
-};
-
-const operationToType = ({
-  context,
-  operation,
-  plugin,
-}: {
-  context: IR.Context;
-  operation: IR.OperationObject;
-  plugin: Plugin.Instance<Config>;
-}) => {
-  operationToDataType({
-    context,
-    operation,
-    plugin,
-  });
-
-  const file = context.file({ id: typesId })!;
-
-  const { error, errors, response, responses } =
-    operationResponsesMap(operation);
-
-  if (errors) {
-    const identifierErrors = file.identifier({
-      $ref: operationIrRef({ id: operation.id, type: 'errors' }),
-      create: true,
-      namespace: 'type',
-    });
-    if (identifierErrors.name) {
-      const type = schemaToType({
-        context,
-        plugin,
-        schema: errors,
-        state:
-          plugin.readOnlyWriteOnlyBehavior === 'off'
-            ? undefined
-            : {
-                accessScope: 'read',
-              },
-      });
-
-      if (type) {
-        const node = compiler.typeAliasDeclaration({
-          exportType: true,
-          name: identifierErrors.name,
-          type,
-        });
-        file.add(node);
-      }
-
-      if (error) {
-        const identifierError = file.identifier({
-          $ref: operationIrRef({ id: operation.id, type: 'error' }),
-          create: true,
-          namespace: 'type',
-        });
-        if (identifierError.name) {
-          const errorsType = compiler.typeReferenceNode({
-            typeName: identifierErrors.name,
-          });
-          const keyofType = ts.factory.createTypeOperatorNode(
-            ts.SyntaxKind.KeyOfKeyword,
-            errorsType,
-          );
-          const node = compiler.typeAliasDeclaration({
-            exportType: true,
-            name: identifierError.name,
-            type: compiler.indexedAccessTypeNode({
-              indexType: keyofType,
-              objectType: errorsType,
-            }),
-          });
-          file.add(node);
-        }
-      }
-    }
-  }
-
-  if (responses) {
-    const identifierResponses = file.identifier({
-      $ref: operationIrRef({ id: operation.id, type: 'responses' }),
-      create: true,
-      namespace: 'type',
-    });
-    if (identifierResponses.name) {
-      const type = schemaToType({
-        context,
-        plugin,
-        schema: responses,
-        state:
-          plugin.readOnlyWriteOnlyBehavior === 'off'
-            ? undefined
-            : {
-                accessScope: 'read',
-              },
-      });
-
-      if (type) {
-        const node = compiler.typeAliasDeclaration({
-          exportType: true,
-          name: identifierResponses.name,
-          type,
-        });
-        file.add(node);
-      }
-
-      if (response) {
-        const identifierResponse = file.identifier({
-          $ref: operationIrRef({ id: operation.id, type: 'response' }),
-          create: true,
-          namespace: 'type',
-        });
-        if (identifierResponse.name) {
-          const responsesType = compiler.typeReferenceNode({
-            typeName: identifierResponses.name,
-          });
-          const keyofType = ts.factory.createTypeOperatorNode(
-            ts.SyntaxKind.KeyOfKeyword,
-            responsesType,
-          );
-          const node = compiler.typeAliasDeclaration({
-            exportType: true,
-            name: identifierResponse.name,
-            type: compiler.indexedAccessTypeNode({
-              indexType: keyofType,
-              objectType: responsesType,
-            }),
-          });
-          file.add(node);
-        }
-      }
-    }
-  }
-};
-
 export const schemaToType = ({
   onRef,
   plugin,

packages/openapi-ts/src/plugins/@pinia/colada/config.ts

@@ -4,7 +4,6 @@ import type { PiniaColadaPlugin } from './types';
 
 export const defaultConfig: PiniaColadaPlugin['Config'] = {
   config: {
-    enableCaching: false,
     enablePaginationOnKey: undefined,
     errorHandling: 'specific',
     exportFromIndex: false,

packages/openapi-ts/src/plugins/@pinia/colada/mutation.ts

@@ -1,7 +1,6 @@
-import type { TypeScriptFile } from '../../../generate/files';
+import type { GeneratedFile } from '../../../generate/file';
 import type { IR } from '../../../ir/types';
-import type { Plugin } from '../../types';
-import type { Config } from './types';
+import type { PiniaColadaPlugin } from './types';
 import { createComposable } from './utils';
 
 /**
@@ -14,12 +13,12 @@ export const createMutationFunction = ({
   plugin,
 }: {
   context: IR.Context;
-  file: TypeScriptFile;
+  file: GeneratedFile;
   operation: IR.OperationObject;
-  plugin: Plugin.Instance<Config>;
+  plugin: PiniaColadaPlugin['Instance'];
 }) => {
   // Allow hooks to customize or skip mutation generation
-  if (plugin?.onMutation && plugin.onMutation(operation) === false) {
+  if (plugin.config.onMutation && plugin.config.onMutation(operation) === false) {
     return;
   }