@fern-api/typescript-dynamic-snippets 0.0.5 → 0.0.7

package/esm/chunk-QMEM6UIZ.js

@@ -1,538 +0,0 @@
-import {
-  Scope,
-  Severity
-} from "./chunk-K6P3GMIJ.js";
-import {
-  __publicField,
-  assertNever,
-  init_buffer,
-  init_process,
-  typescript_exports
-} from "./chunk-SGEN5HN3.js";
-
-// src/EndpointSnippetGenerator.ts
-init_process();
-init_buffer();
-var CLIENT_VAR_NAME = "client";
-var MAIN_FUNCTION_NAME = "main";
-var STRING_TYPE_REFERENCE = {
-  type: "primitive",
-  value: "STRING"
-};
-var EndpointSnippetGenerator = class {
-  constructor({ context }) {
-    __publicField(this, "context");
-    this.context = context;
-  }
-  async generateSnippet({
-    endpoint,
-    request
-  }) {
-    const code = this.buildCodeBlock({ endpoint, snippet: request });
-    return await code.toString({ customConfig: this.context.customConfig });
-  }
-  generateSnippetSync({
-    endpoint,
-    request
-  }) {
-    const code = this.buildCodeBlock({ endpoint, snippet: request });
-    return code.toStringSync({ customConfig: this.context.customConfig });
-  }
-  buildCodeBlock({
-    endpoint,
-    snippet
-  }) {
-    return typescript_exports.codeblock((writer) => {
-      writer.writeNode(
-        typescript_exports.function_({
-          name: MAIN_FUNCTION_NAME,
-          async: true,
-          parameters: [],
-          body: typescript_exports.codeblock((writer2) => {
-            writer2.writeNodeStatement(this.constructClient({ endpoint, snippet }));
-            writer2.writeNodeStatement(this.callMethod({ endpoint, snippet }));
-          })
-        })
-      );
-      writer.writeNodeStatement(
-        typescript_exports.invokeFunction({
-          function_: typescript_exports.reference({
-            name: MAIN_FUNCTION_NAME
-          }),
-          arguments_: []
-        })
-      );
-    });
-  }
-  constructClient({
-    endpoint,
-    snippet
-  }) {
-    return typescript_exports.variable({
-      name: CLIENT_VAR_NAME,
-      const: true,
-      initializer: typescript_exports.instantiateClass({
-        class_: typescript_exports.reference({
-          name: this.context.getRootClientName(),
-          importFrom: this.context.getModuleImport()
-        }),
-        arguments_: [this.getConstructorArgs({ endpoint, snippet })]
-      })
-    });
-  }
-  getConstructorArgs({
-    endpoint,
-    snippet
-  }) {
-    const fields = [];
-    const environmentArgs = this.getConstructorEnvironmentArgs({
-      baseUrl: snippet.baseURL,
-      environment: snippet.environment
-    });
-    if (environmentArgs.length > 0) {
-      fields.push(...environmentArgs);
-    }
-    if (endpoint.auth != null) {
-      if (snippet.auth != null) {
-        fields.push(...this.getConstructorAuthArgs({ auth: endpoint.auth, values: snippet.auth }));
-      } else {
-        this.context.errors.add({
-          severity: Severity.Warning,
-          message: `Auth with ${endpoint.auth.type} configuration is required for this endpoint`
-        });
-      }
-    }
-    this.context.errors.scope(Scope.Headers);
-    if (this.context.ir.headers != null && snippet.headers != null) {
-      fields.push(
-        ...this.getConstructorHeaderArgs({ headers: this.context.ir.headers, values: snippet.headers })
-      );
-    }
-    this.context.errors.unscope();
-    if (fields.length === 0) {
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return typescript_exports.TypeLiteral.object({ fields });
-  }
-  getConstructorEnvironmentArgs({
-    baseUrl,
-    environment
-  }) {
-    const environmentValue = this.getEnvironmentValue({ baseUrl, environment });
-    if (environmentValue == null) {
-      return [];
-    }
-    return [
-      {
-        name: "environment",
-        value: environmentValue
-      }
-    ];
-  }
-  getEnvironmentValue({
-    baseUrl,
-    environment
-  }) {
-    if (baseUrl != null && environment != null) {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: "Cannot specify both baseUrl and environment options"
-      });
-      return void 0;
-    }
-    if (baseUrl != null) {
-      return typescript_exports.TypeLiteral.string(baseUrl);
-    }
-    if (environment != null) {
-      if (this.context.isSingleEnvironmentID(environment)) {
-        const environmentTypeReference = this.context.getEnvironmentTypeReferenceFromID(environment);
-        if (environmentTypeReference == null) {
-          this.context.errors.add({
-            severity: Severity.Warning,
-            message: `Environment ${JSON.stringify(environment)} was not found`
-          });
-          return void 0;
-        }
-        return typescript_exports.TypeLiteral.reference(environmentTypeReference);
-      }
-      if (this.context.isMultiEnvironmentValues(environment)) {
-        if (!this.context.validateMultiEnvironmentUrlValues(environment)) {
-          return void 0;
-        }
-        return typescript_exports.TypeLiteral.object({
-          fields: Object.entries(environment).map(([key, value]) => ({
-            name: key,
-            value: this.context.dynamicTypeLiteralMapper.convert({
-              typeReference: STRING_TYPE_REFERENCE,
-              value
-            })
-          }))
-        });
-      }
-    }
-    return void 0;
-  }
-  getConstructorAuthArgs({
-    auth,
-    values
-  }) {
-    switch (auth.type) {
-      case "basic":
-        if (values.type !== "basic") {
-          this.context.errors.add({
-            severity: Severity.Critical,
-            message: this.context.newAuthMismatchError({ auth, values }).message
-          });
-          return [];
-        }
-        return this.getConstructorBasicAuthArg({ auth, values });
-      case "bearer":
-        if (values.type !== "bearer") {
-          this.context.errors.add({
-            severity: Severity.Critical,
-            message: this.context.newAuthMismatchError({ auth, values }).message
-          });
-          return [];
-        }
-        return this.getConstructorBearerAuthArgs({ auth, values });
-      case "header":
-        if (values.type !== "header") {
-          this.context.errors.add({
-            severity: Severity.Critical,
-            message: this.context.newAuthMismatchError({ auth, values }).message
-          });
-          return [];
-        }
-        return this.getConstructorHeaderAuthArgs({ auth, values });
-      default:
-        assertNever(auth);
-    }
-  }
-  getConstructorBasicAuthArg({
-    auth,
-    values
-  }) {
-    return [
-      {
-        name: this.context.getPropertyName(auth.username),
-        value: typescript_exports.TypeLiteral.string(values.username)
-      },
-      {
-        name: this.context.getPropertyName(auth.password),
-        value: typescript_exports.TypeLiteral.string(values.password)
-      }
-    ];
-  }
-  getConstructorBearerAuthArgs({
-    auth,
-    values
-  }) {
-    return [
-      {
-        name: this.context.getPropertyName(auth.token),
-        value: typescript_exports.TypeLiteral.string(values.token)
-      }
-    ];
-  }
-  getConstructorHeaderAuthArgs({
-    auth,
-    values
-  }) {
-    return [
-      {
-        name: this.context.getPropertyName(auth.header.name.name),
-        value: this.context.dynamicTypeLiteralMapper.convert({
-          typeReference: auth.header.typeReference,
-          value: values.value
-        })
-      }
-    ];
-  }
-  getConstructorHeaderArgs({
-    headers,
-    values
-  }) {
-    const fields = [];
-    for (const header of headers) {
-      const field = this.getConstructorHeaderArg({ header, value: values.value });
-      if (field != null) {
-        fields.push(field);
-      }
-    }
-    return fields;
-  }
-  getConstructorHeaderArg({
-    header,
-    value
-  }) {
-    const typeLiteral = this.context.dynamicTypeLiteralMapper.convert({
-      typeReference: header.typeReference,
-      value
-    });
-    if (typescript_exports.TypeLiteral.isNop(typeLiteral)) {
-      return void 0;
-    }
-    return {
-      name: this.context.getPropertyName(header.name.name),
-      value: typeLiteral
-    };
-  }
-  callMethod({
-    endpoint,
-    snippet
-  }) {
-    return typescript_exports.invokeMethod({
-      on: typescript_exports.reference({ name: CLIENT_VAR_NAME }),
-      method: this.getMethod({ endpoint }),
-      async: true,
-      arguments_: this.getMethodArgs({ endpoint, snippet })
-    });
-  }
-  getMethodArgs({
-    endpoint,
-    snippet
-  }) {
-    switch (endpoint.request.type) {
-      case "inlined":
-        return this.getMethodArgsForInlinedRequest({ request: endpoint.request, snippet });
-      case "body":
-        return this.getMethodArgsForBodyRequest({ request: endpoint.request, snippet });
-      default:
-        assertNever(endpoint.request);
-    }
-  }
-  getMethodArgsForBodyRequest({
-    request,
-    snippet
-  }) {
-    const args = [];
-    this.context.errors.scope(Scope.PathParameters);
-    if (request.pathParameters != null) {
-      const pathParameterFields = this.getPathParameters({ namedParameters: request.pathParameters, snippet });
-      args.push(...pathParameterFields.map((field) => field.value));
-    }
-    this.context.errors.unscope();
-    this.context.errors.scope(Scope.RequestBody);
-    if (request.body != null) {
-      args.push(this.getBodyRequestArg({ body: request.body, value: snippet.requestBody }));
-    }
-    this.context.errors.unscope();
-    return args;
-  }
-  getBodyRequestArg({
-    body,
-    value
-  }) {
-    switch (body.type) {
-      case "bytes":
-        return this.getBytesBodyRequestArg({ value });
-      case "typeReference":
-        return this.context.dynamicTypeLiteralMapper.convert({ typeReference: body.value, value });
-      default:
-        assertNever(body);
-    }
-  }
-  getBytesBodyRequestArg({ value }) {
-    if (typeof value !== "string") {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: `Expected bytes value to be a string, got ${typeof value}`
-      });
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return typescript_exports.TypeLiteral.blob(value);
-  }
-  getMethodArgsForInlinedRequest({
-    request,
-    snippet
-  }) {
-    var _a, _b, _c, _d;
-    const args = [];
-    const { inlinePathParameters, inlineFileProperties } = {
-      inlinePathParameters: (_b = (_a = this.context.customConfig) == null ? void 0 : _a.inlinePathParameters) != null ? _b : false,
-      inlineFileProperties: (_d = (_c = this.context.customConfig) == null ? void 0 : _c.inlineFileProperties) != null ? _d : false
-    };
-    this.context.errors.scope(Scope.PathParameters);
-    const pathParameterFields = [];
-    if (request.pathParameters != null) {
-      pathParameterFields.push(...this.getPathParameters({ namedParameters: request.pathParameters, snippet }));
-    }
-    this.context.errors.unscope();
-    this.context.errors.scope(Scope.RequestBody);
-    const filePropertyInfo = this.getFilePropertyInfo({ request, snippet });
-    this.context.errors.unscope();
-    if (!this.context.includePathParametersInWrappedRequest({
-      request,
-      inlinePathParameters
-    })) {
-      args.push(...pathParameterFields.map((field) => field.value));
-    }
-    if (!inlineFileProperties) {
-      args.push(...filePropertyInfo.fileFields.map((field) => field.value));
-    }
-    if (this.context.needsRequestParameter({
-      request,
-      inlinePathParameters,
-      inlineFileProperties
-    })) {
-      args.push(
-        this.getInlinedRequestArg({
-          request,
-          snippet,
-          pathParameterFields: this.context.includePathParametersInWrappedRequest({
-            request,
-            inlinePathParameters
-          }) ? pathParameterFields : [],
-          filePropertyInfo
-        })
-      );
-    }
-    return args;
-  }
-  getFilePropertyInfo({
-    request,
-    snippet
-  }) {
-    if (request.body == null || !this.context.isFileUploadRequestBody(request.body)) {
-      return {
-        fileFields: [],
-        bodyPropertyFields: []
-      };
-    }
-    return this.context.filePropertyMapper.getFilePropertyInfo({
-      body: request.body,
-      value: snippet.requestBody
-    });
-  }
-  getInlinedRequestArg({
-    request,
-    snippet,
-    pathParameterFields,
-    filePropertyInfo
-  }) {
-    var _a, _b, _c, _d;
-    this.context.errors.scope(Scope.QueryParameters);
-    const queryParameters = this.context.associateQueryParametersByWireValue({
-      parameters: (_a = request.queryParameters) != null ? _a : [],
-      values: (_b = snippet.queryParameters) != null ? _b : {}
-    });
-    const queryParameterFields = queryParameters.map((queryParameter) => ({
-      name: this.context.getPropertyName(queryParameter.name.name),
-      value: this.context.dynamicTypeLiteralMapper.convert(queryParameter)
-    }));
-    this.context.errors.unscope();
-    this.context.errors.scope(Scope.Headers);
-    const headers = this.context.associateByWireValue({
-      parameters: (_c = request.headers) != null ? _c : [],
-      values: (_d = snippet.headers) != null ? _d : {}
-    });
-    const headerFields = headers.map((header) => ({
-      name: this.context.getPropertyName(header.name.name),
-      value: this.context.dynamicTypeLiteralMapper.convert(header)
-    }));
-    this.context.errors.unscope();
-    this.context.errors.scope(Scope.RequestBody);
-    const requestBodyFields = request.body != null ? this.getInlinedRequestBodyObjectFields({
-      body: request.body,
-      value: snippet.requestBody,
-      filePropertyInfo
-    }) : [];
-    this.context.errors.unscope();
-    return typescript_exports.TypeLiteral.object({
-      fields: [...pathParameterFields, ...queryParameterFields, ...headerFields, ...requestBodyFields]
-    });
-  }
-  getInlinedRequestBodyObjectFields({
-    body,
-    value,
-    filePropertyInfo
-  }) {
-    switch (body.type) {
-      case "properties":
-        return this.getInlinedRequestBodyPropertyObjectFields({ parameters: body.value, value });
-      case "referenced":
-        return [this.getReferencedRequestBodyPropertyObjectField({ body, value })];
-      case "fileUpload":
-        return this.getFileUploadRequestBodyObjectFields({ filePropertyInfo });
-      default:
-        assertNever(body);
-    }
-  }
-  getFileUploadRequestBodyObjectFields({
-    filePropertyInfo
-  }) {
-    var _a;
-    if ((_a = this.context.customConfig) == null ? void 0 : _a.inlineFileProperties) {
-      return [...filePropertyInfo.fileFields, ...filePropertyInfo.bodyPropertyFields];
-    }
-    return filePropertyInfo.bodyPropertyFields;
-  }
-  getReferencedRequestBodyPropertyObjectField({
-    body,
-    value
-  }) {
-    return {
-      name: this.context.getPropertyName(body.bodyKey),
-      value: this.getReferencedRequestBodyPropertyTypeLiteral({ body: body.bodyType, value })
-    };
-  }
-  getReferencedRequestBodyPropertyTypeLiteral({
-    body,
-    value
-  }) {
-    switch (body.type) {
-      case "bytes":
-        return this.getBytesBodyRequestArg({ value });
-      case "typeReference":
-        return this.context.dynamicTypeLiteralMapper.convert({ typeReference: body.value, value });
-      default:
-        assertNever(body);
-    }
-  }
-  getInlinedRequestBodyPropertyObjectFields({
-    parameters,
-    value
-  }) {
-    var _a;
-    const fields = [];
-    const bodyProperties = this.context.associateByWireValue({
-      parameters,
-      values: (_a = this.context.getRecord(value)) != null ? _a : {}
-    });
-    for (const parameter of bodyProperties) {
-      fields.push({
-        name: this.context.getPropertyName(parameter.name.name),
-        value: this.context.dynamicTypeLiteralMapper.convert(parameter)
-      });
-    }
-    return fields;
-  }
-  getPathParameters({
-    namedParameters,
-    snippet
-  }) {
-    var _a;
-    const args = [];
-    const pathParameters = this.context.associateByWireValue({
-      parameters: namedParameters,
-      values: (_a = snippet.pathParameters) != null ? _a : {}
-    });
-    for (const parameter of pathParameters) {
-      args.push({
-        name: this.context.getPropertyName(parameter.name.name),
-        value: this.context.dynamicTypeLiteralMapper.convert(parameter)
-      });
-    }
-    return args;
-  }
-  getMethod({ endpoint }) {
-    if (endpoint.declaration.fernFilepath.allParts.length > 0) {
-      return `${endpoint.declaration.fernFilepath.allParts.map((val) => this.context.getMethodName(val)).join(".")}.${this.context.getMethodName(endpoint.declaration.name)}`;
-    }
-    return this.context.getMethodName(endpoint.declaration.name);
-  }
-};
-
-export {
-  EndpointSnippetGenerator
-};