Generate common class methods

Author: razor-x

codegen/layouts/partials/route-class-methods.hbs

@@ -0,0 +1,125 @@
+client: Client
+readonly defaults: Required<SeamHttpRequestOptions>
+readonly ltsVersion = seamApiLtsVersion
+static ltsVersion = seamApiLtsVersion
+
+constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+  const options = parseOptions(apiKeyOrOptions)
+  this.client = 'client' in options ? options.client : createClient(options)
+  this.defaults = limitToSeamHttpRequestOptions(options)
+}
+
+static fromClient(
+  client: SeamHttpOptionsWithClient['client'],
+  options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
+): {{className}} {
+  const constructorOptions = { ...options, client }
+  if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+    throw new SeamHttpInvalidOptionsError('Missing client')
+  }
+  return new {{className}}(constructorOptions)
+}
+
+static fromApiKey(
+  apiKey: SeamHttpOptionsWithApiKey['apiKey'],
+  options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
+): {{className}} {
+  const constructorOptions = { ...options, apiKey }
+  if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+    throw new SeamHttpInvalidOptionsError('Missing apiKey')
+  }
+  return new {{className}}(constructorOptions)
+}
+
+static fromClientSessionToken(
+  clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+  options: Omit<
+    SeamHttpOptionsWithClientSessionToken,
+    'clientSessionToken'
+  > = {},
+): {{className}} {
+  const constructorOptions = { ...options, clientSessionToken }
+  if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+    throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
+  }
+  return new {{className}}(constructorOptions)
+}
+
+static async fromPublishableKey(
+  publishableKey: string,
+  userIdentifierKey: string,
+  options: SeamHttpFromPublishableKeyOptions = {},
+): Promise<{{className}}> {
+  warnOnInsecureuserIdentifierKey(userIdentifierKey)
+  const clientOptions = parseOptions({ ...options, publishableKey })
+  if (isSeamHttpOptionsWithClient(clientOptions)) {
+    throw new SeamHttpInvalidOptionsError(
+      'The client option cannot be used with {{className}}.fromPublishableKey',
+    )
+  }
+  const client = createClient(clientOptions)
+  const clientSessions = SeamHttpClientSessions.fromClient(client)
+  const { token } = await clientSessions.getOrCreate({
+    user_identifier_key: userIdentifierKey,
+  })
+  return {{className}}.fromClientSessionToken(token, options)
+}
+
+static fromConsoleSessionToken(
+  consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+  workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+  options: Omit<
+    SeamHttpOptionsWithConsoleSessionToken,
+    'consoleSessionToken' | 'workspaceId'
+  > = {},
+): {{className}} {
+  const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+  if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+    throw new SeamHttpInvalidOptionsError(
+      'Missing consoleSessionToken or workspaceId',
+    )
+  }
+  return new {{className}}(constructorOptions)
+}
+
+static fromPersonalAccessToken(
+  personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+  workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+  options: Omit<
+    SeamHttpOptionsWithPersonalAccessToken,
+    'personalAccessToken' | 'workspaceId'
+  > = {},
+): {{className}} {
+  const constructorOptions = { ...options, personalAccessToken, workspaceId }
+  if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+    throw new SeamHttpInvalidOptionsError(
+      'Missing personalAccessToken or workspaceId',
+    )
+  }
+  return new {{className}}(constructorOptions)
+}
+
+createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(
+  request: SeamHttpRequest<TResponse, TResponseKey>,
+): SeamPaginator<TResponse, TResponseKey> {
+  return new SeamPaginator<TResponse, TResponseKey>(this, request)
+}
+
+async updateClientSessionToken(
+  clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+): Promise<void> {
+  const { headers } = this.client.defaults
+  const authHeaders = getAuthHeadersForClientSessionToken({
+    clientSessionToken,
+  })
+  for (const key of Object.keys(authHeaders)) {
+    if (headers[key] == null) {
+      throw new Error(
+        'Cannot update a clientSessionToken on a client created without a clientSessionToken',
+      )
+    }
+  }
+  this.client.defaults.headers = { ...headers, ...authHeaders }
+  const clientSessions = SeamHttpClientSessions.fromClient(this.client)
+  await clientSessions.get()
+}

codegen/layouts/partials/route-imports.hbs

@@ -0,0 +1,51 @@
+import type {
+  RouteRequestBody,
+  RouteRequestParams,
+  RouteResponse,
+} from '@seamapi/types/connect'
+import type { SetNonNullable } from 'lib/types.js'
+
+import {
+  getAuthHeadersForClientSessionToken,
+  warnOnInsecureuserIdentifierKey,
+} from 'lib/seam/connect/auth.js'
+import {
+  type Client,
+  type ClientOptions,
+  createClient,
+} from 'lib/seam/connect/client.js'
+import {
+  isSeamHttpOptionsWithApiKey,
+  isSeamHttpOptionsWithClient,
+  isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpFromPublishableKeyOptions,
+  SeamHttpInvalidOptionsError,
+  type SeamHttpOptions,
+  type SeamHttpOptionsWithApiKey,
+  type SeamHttpOptionsWithClient,
+  type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
+} from 'lib/seam/connect/options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions
+} from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
+import { SeamPaginator } from 'lib/seam/connect/seam-paginator.js'
+
+{{#if isClientSessionRoute}}
+import { SeamHttpClientSessions } from './client-sessions.js'
+{{/if}}
+
+{{#if needsActionAttempts}}
+import {
+  resolveActionAttempt,
+} from 'lib/seam/connect/resolve-action-attempt.js'
+{{#unless isActionAttemptsRoute}}
+import { SeamHttpActionAttempts } from './action-attempts.js'
+{{/unless}}
+{{/if}}

codegen/layouts/route.hbs

@@ -1 +1,5 @@
-{{contents}}
+{{> route-imports }}
+
+class {{routeName}} {
+  {{> route-class-methods }}
+}

codegen/lib/connect.ts

@@ -32,13 +32,19 @@ export const connect = (
 }
 
 interface RouteLayoutContext {
-  routeName: string
+  className: string
+  isClientSessionRoute: boolean
+  isActionAttemptsRoute: boolean
+  needsActionAttempts: boolean
 }
 
 const setRouteLayoutContext = (
   file: Partial<RouteLayoutContext>,
   route: Route,
   _blueprint: Blueprint,
 ): void => {
-  file.routeName = pascalCase(route.name)
+  file.className = `SeamHttp${pascalCase(route.name)}`
+  file.needsActionAttempts = false
+  file.isClientSessionRoute = route.name === '/client_sessions'
+  file.isActionAttemptsRoute = route.name === '/action_attempts'
 }