js: Replace OpenAPI generator http code with our own

javascript/src/api/application.ts

@@ -1,13 +1,12 @@
-// this file is @generated (with the exception of getOrCreate)
+// this file is @generated
 import {
-  Configuration,
-  ApplicationApi,
   ApplicationIn,
   ApplicationOut,
   ApplicationPatch,
   ListResponseApplicationOut,
   Ordering,
 } from "../openapi";
+import { HttpMethod, SvixRequest, SvixRequestContext } from "../request";
 import { PostOptions } from "../util";
 
 export interface ApplicationListOptions {
@@ -20,73 +19,95 @@ export interface ApplicationListOptions {
 }
 
 export class Application {
-  private readonly api: ApplicationApi;
-
-  public constructor(config: Configuration) {
-    this.api = new ApplicationApi(config);
-  }
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
 
   /** List of all the organization's applications. */
-  public list(options?: ApplicationListOptions): Promise<ListResponseApplicationOut> {
-    return this.api.v1ApplicationList({
-      ...options,
-      iterator: options?.iterator ?? undefined,
-    });
+  public async list(
+    options?: ApplicationListOptions
+  ): Promise<ListResponseApplicationOut> {
+    const request = new SvixRequest(HttpMethod.GET, "/api/v1/app");
+
+    request.setQueryParam("limit", options?.limit);
+    request.setQueryParam("iterator", options?.iterator);
+    request.setQueryParam("order", options?.order);
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as ListResponseApplicationOut;
   }
 
   /** Create a new application. */
-  public create(
+  public async create(
     applicationIn: ApplicationIn,
     options?: PostOptions
   ): Promise<ApplicationOut> {
-    return this.api.v1ApplicationCreate({
-      applicationIn,
-      ...options,
-    });
+    const request = new SvixRequest(HttpMethod.POST, "/api/v1/app");
+
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+    request.body = applicationIn;
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as ApplicationOut;
   }
 
   /** Get the application with the UID from `applicationIn`, or create it if it doesn't exist yet. */
-  public getOrCreate(
+  public async getOrCreate(
     applicationIn: ApplicationIn,
     options?: PostOptions
   ): Promise<ApplicationOut> {
-    return this.api.v1ApplicationCreate({
-      applicationIn,
-      ...options,
-      getIfExists: true,
-    });
+    const request = new SvixRequest(HttpMethod.POST, "/api/v1/app");
+
+    request.body = applicationIn;
+    request.setQueryParam("get_if_exists", true);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+
+    const responseBody: any = await request.send(this.requestCtx);
+    return responseBody as ApplicationOut;
   }
 
   /** Get an application. */
-  public get(appId: string): Promise<ApplicationOut> {
-    return this.api.v1ApplicationGet({
-      appId,
-    });
+  public async get(appId: string): Promise<ApplicationOut> {
+    const request = new SvixRequest(HttpMethod.GET, "/api/v1/app/{app_id}");
+
+    request.setPathParam("app_id", appId);
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as ApplicationOut;
   }
 
   /** Update an application. */
-  public update(appId: string, applicationIn: ApplicationIn): Promise<ApplicationOut> {
-    return this.api.v1ApplicationUpdate({
-      appId,
-      applicationIn,
-    });
+  public async update(
+    appId: string,
+    applicationIn: ApplicationIn
+  ): Promise<ApplicationOut> {
+    const request = new SvixRequest(HttpMethod.PUT, "/api/v1/app/{app_id}");
+
+    request.setPathParam("app_id", appId);
+    request.body = applicationIn;
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as ApplicationOut;
   }
 
   /** Delete an application. */
-  public delete(appId: string): Promise<void> {
-    return this.api.v1ApplicationDelete({
-      appId,
-    });
+  public async delete(appId: string): Promise<void> {
+    const request = new SvixRequest(HttpMethod.DELETE, "/api/v1/app/{app_id}");
+
+    request.setPathParam("app_id", appId);
+
+    await request.send(this.requestCtx);
   }
 
   /** Partially update an application. */
-  public patch(
+  public async patch(
     appId: string,
     applicationPatch: ApplicationPatch
   ): Promise<ApplicationOut> {
-    return this.api.v1ApplicationPatch({
-      appId,
-      applicationPatch,
-    });
+    const request = new SvixRequest(HttpMethod.PATCH, "/api/v1/app/{app_id}");
+
+    request.setPathParam("app_id", appId);
+    request.body = applicationPatch;
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as ApplicationOut;
   }
 }

javascript/src/api/authentication.ts

@@ -1,45 +1,51 @@
 // this file is @generated
 import {
-  Configuration,
-  AuthenticationApi,
   AppPortalAccessIn,
   AppPortalAccessOut,
   ApplicationTokenExpireIn,
   DashboardAccessOut,
 } from "../openapi";
+import { HttpMethod, SvixRequest, SvixRequestContext } from "../request";
 import { PostOptions } from "../util";
 
 export class Authentication {
-  private readonly api: AuthenticationApi;
-
-  public constructor(config: Configuration) {
-    this.api = new AuthenticationApi(config);
-  }
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
 
   /** Use this function to get magic links (and authentication codes) for connecting your users to the Consumer Application Portal. */
-  public appPortalAccess(
+  public async appPortalAccess(
     appId: string,
     appPortalAccessIn: AppPortalAccessIn,
     options?: PostOptions
   ): Promise<AppPortalAccessOut> {
-    return this.api.v1AuthenticationAppPortalAccess({
-      appId,
-      appPortalAccessIn,
-      ...options,
-    });
+    const request = new SvixRequest(
+      HttpMethod.POST,
+      "/api/v1/auth/app-portal-access/{app_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+    request.body = appPortalAccessIn;
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as AppPortalAccessOut;
   }
 
   /** Expire all of the tokens associated with a specific application. */
-  public expireAll(
+  public async expireAll(
     appId: string,
     applicationTokenExpireIn: ApplicationTokenExpireIn,
     options?: PostOptions
   ): Promise<void> {
-    return this.api.v1AuthenticationExpireAll({
-      appId,
-      applicationTokenExpireIn,
-      ...options,
-    });
+    const request = new SvixRequest(
+      HttpMethod.POST,
+      "/api/v1/auth/app/{app_id}/expire-all"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+    request.body = applicationTokenExpireIn;
+
+    await request.send(this.requestCtx);
   }
 
   /**
@@ -49,24 +55,32 @@ export class Authentication {
    *
    * @deprecated
    */
-  public dashboardAccess(
+  public async dashboardAccess(
     appId: string,
     options?: PostOptions
   ): Promise<DashboardAccessOut> {
-    return this.api.v1AuthenticationDashboardAccess({
-      appId,
-      ...options,
-    });
+    const request = new SvixRequest(
+      HttpMethod.POST,
+      "/api/v1/auth/dashboard-access/{app_id}"
+    );
+
+    request.setPathParam("app_id", appId);
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as DashboardAccessOut;
   }
 
   /**
    * Logout an app token.
    *
    * Trying to log out other tokens will fail.
    */
-  public logout(options?: PostOptions): Promise<void> {
-    return this.api.v1AuthenticationLogout({
-      ...options,
-    });
+  public async logout(options?: PostOptions): Promise<void> {
+    const request = new SvixRequest(HttpMethod.POST, "/api/v1/auth/logout");
+
+    request.setHeaderParam("idempotency-key", options?.idempotencyKey);
+
+    await request.send(this.requestCtx);
   }
 }

javascript/src/api/background_task.ts

@@ -1,13 +1,12 @@
 // this file is @generated
 import {
-  Configuration,
-  BackgroundTasksApi,
   BackgroundTaskOut,
   BackgroundTaskStatus,
   BackgroundTaskType,
   ListResponseBackgroundTaskOut,
   Ordering,
 } from "../openapi";
+import { HttpMethod, SvixRequest, SvixRequestContext } from "../request";
 
 export interface BackgroundTaskListOptions {
   /** Filter the response based on the status. */
@@ -23,20 +22,22 @@ export interface BackgroundTaskListOptions {
 }
 
 export class BackgroundTask {
-  private readonly api: BackgroundTasksApi;
-
-  public constructor(config: Configuration) {
-    this.api = new BackgroundTasksApi(config);
-  }
+  public constructor(private readonly requestCtx: SvixRequestContext) {}
 
   /** List background tasks executed in the past 90 days. */
-  public list(
+  public async list(
     options?: BackgroundTaskListOptions
   ): Promise<ListResponseBackgroundTaskOut> {
-    return this.api.listBackgroundTasks({
-      ...options,
-      iterator: options?.iterator ?? undefined,
-    });
+    const request = new SvixRequest(HttpMethod.GET, "/api/v1/background-task");
+
+    request.setQueryParam("status", options?.status);
+    request.setQueryParam("task", options?.task);
+    request.setQueryParam("limit", options?.limit);
+    request.setQueryParam("iterator", options?.iterator);
+    request.setQueryParam("order", options?.order);
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as ListResponseBackgroundTaskOut;
   }
 
   /**
@@ -51,9 +52,12 @@ export class BackgroundTask {
   }
 
   /** Get a background task by ID. */
-  public get(taskId: string): Promise<BackgroundTaskOut> {
-    return this.api.getBackgroundTask({
-      taskId,
-    });
+  public async get(taskId: string): Promise<BackgroundTaskOut> {
+    const request = new SvixRequest(HttpMethod.GET, "/api/v1/background-task/{task_id}");
+
+    request.setPathParam("task_id", taskId);
+
+    const responseBody = await request.send(this.requestCtx);
+    return responseBody as BackgroundTaskOut;
   }
 }