@owlmeans/client-entrypoint 0.1.18-rc.5 → 0.1.18-rc.50

package/src/utils/handler.ts

@@ -1,53 +1,62 @@
 import type { ApiClient } from '@owlmeans/api'
 import { DEFAULT_KEY } from '@owlmeans/client-config'
-import type { ClientConfig, ClientContext } from '@owlmeans/client-context'
-import type { AbstractRequest, EntrypointHandler } from '@owlmeans/entrypoint'
-import { EntrypointOutcome, provideResponse } from '@owlmeans/entrypoint'
-import type { ClientEntrypoint, EntrypointCall, ClientEntrypointOptions, EntrypointRef, ClientRequest } from '../types.js'
+import { type AbstractRequest, type EntrypointHandler, type EntrypointTransport, EntrypointOutcome, provideResponse, transportAlias } from '@owlmeans/entrypoint'
+import type { ClientEntrypoint, EntrypointInvoke, EntrypointUrlOptions, ClientEntrypointOptions, EntrypointRef, ClientRequest, EntrypointFailureService } from '../types.js'
 import { validate } from './entrypoint.js'
-import { extractParams } from '@owlmeans/client-route'
-import { PARAM } from '@owlmeans/route'
+import { clientRouteHelper } from '@owlmeans/client-route'
+import { PARAM, RouteMethod, RouteProtocols } from '@owlmeans/route'
 import { stringify } from 'qs'
-import { assertContext } from '@owlmeans/context'
+import { assertContext, memoHelper } from '@owlmeans/context'
 import { makeSecurityHelper } from '@owlmeans/config'
+import { ENTRYPOINT_FAILURE_SERVICE } from '../consts.js'
+import { logger } from '@owlmeans/log'
+import type { Config, Context } from './types.local.js'
+import type { ApiCallHelper } from './handler/types.js'
+
+const log = logger('client-entrypoint')
+
+export const makeApiCallHelper = <T, R extends AbstractRequest = AbstractRequest>(
+  ref: EntrypointRef<T, R>
+): ApiCallHelper<T, R> => {
+  const apiHandler: EntrypointHandler = async (req, res) => {
+    const location = `client-entrypoint:api-handler:${ref.ref?.alias}`
+    const context = assertContext<Config, Context>(ref.ref?.ctx as Context, location)
+
+    if (context.cfg.webService == null) {
+      throw new SyntaxError('No webService provided')
+    }
 
-type Config = ClientConfig
-interface Context<C extends Config = Config> extends ClientContext<C> { }
+    const ep = context.entrypoint<ClientEntrypoint>(req.alias)
 
-export const apiHandler: <
-  T, R extends AbstractRequest = AbstractRequest
->(ref: EntrypointRef<T, R>) => EntrypointHandler = (ref) => async (req, res) => {
-  const location = `client-entrypoint:api-handler:${ref.ref?.alias}`
-  const context = assertContext<Config, Context>(ref.ref?.ctx as Context, location)
+    // A route names the protocol it answers on. Whatever is bound under that protocol takes the
+    // call, so a consumer writes `ep.call(...)` without learning which transport ran.
+    const transport = transportAlias(ep.route.route.protocol)
+    if (context.hasService(transport)) {
+      req.path = ep.path()
 
-  if (context.cfg.webService == null) {
-    throw new SyntaxError('No webService provided')
-  }
+      return context.service<EntrypointTransport>(transport).handle(req, res)
+    }
 
-  const ep = context.entrypoint<ClientEntrypoint>(req.alias)
-  const route = await ep.route.resolve<Config, Context>(context)
+    // Which web client carries this call is decided by the service the route answers on — the one it
+    // names, or the one the context picks for its app type when it names none.
+    const route = ep.service()
 
-  let alias: string | undefined = typeof context.cfg.webService === 'string'
-    ? context.cfg.webService
-    : (route.service != null
-      ? context.cfg.webService[route.service] ?? context.cfg.webService[DEFAULT_KEY]
-      : context.cfg.webService[DEFAULT_KEY])
+    const alias: string | undefined = typeof context.cfg.webService === 'string'
+      ? context.cfg.webService
+      : context.cfg.webService[route.service] ?? context.cfg.webService[DEFAULT_KEY]
 
-  if (alias == null) {
-    throw new SyntaxError(`Can't cast web service alias for ${ep.alias} entrypoint`)
-  }
+    if (alias == null) {
+      throw new SyntaxError(`Can't cast web service alias for ${ep.alias} entrypoint`)
+    }
 
-  const service: ApiClient = context.service(alias)
+    const service: ApiClient = context.service(alias)
 
-  req.path = ep.getPath()
+    req.path = ep.path()
 
-  return service.handler(req, res as any)
-}
+    return service.handler(req, res as any)
+  }
 
-export const apiCall: <
-  T, R extends AbstractRequest = AbstractRequest
->(ref: EntrypointRef<T, R>, opts?: ClientEntrypointOptions) => EntrypointCall<T, R> =
-  (ref, opts) => (async (req, res) => {
+  const apiInvoke = (opts?: ClientEntrypointOptions): EntrypointInvoke<T, R> => (async (req: Partial<R> | undefined) => {
     const ep = ref.ref
     if (ep == null) {
       throw new SyntaxError('Try to make API call before the entrypoint is created')
@@ -56,21 +65,24 @@ export const apiCall: <
     if (ctx == null) {
       throw new SyntaxError(`No context provided in apiCall for ${ep.alias} entrypoint`)
     }
-    await ep.route.resolve(ctx)
 
     if (req?.canceled) {
-      return
+      return { value: null, outcome: EntrypointOutcome.Ok }
     }
 
     const request: AbstractRequest = {
       alias: ep.alias,
       params: req?.params ?? {},
-      body: req?.body,
+      // JSON transports must send a body for mutation methods even when the contract has no
+      // payload.  Keeping that rule here makes every typed caller use `call({ params })`, never
+      // an SDK-specific `{ body: {} }` workaround.
+      body: req?.body ?? ([RouteMethod.POST, RouteMethod.PUT, RouteMethod.PATCH]
+        .includes(ep.route.route.method ?? RouteMethod.GET) ? {} : undefined),
       headers: req?.headers ?? {},
       query: req?.query ?? {},
       host: req?.host,
       base: req?.base,
-      path: ep.getPath(),
+      path: ep.path(),
       timeout: req?.timeout,
       signal: req?.signal,
     }
@@ -85,54 +97,71 @@ export const apiCall: <
       try {
         await validate(ref)(request)
       } catch (e) {
-        console.error(e)
+        log.error('Request validation failed', { alias: ep.alias, error: e })
         throw e
       }
     }
-    if (res != null) {
-      await apiHandler(ref)(request, res)
-      return
-    }
     const reply = provideResponse<unknown>()
     if (ctx == null && ep.ctx == null) {
       throw new SyntaxError(`Use entrypoint ${ep.alias} without context`)
     }
-    await apiHandler(ref)(request, reply)
-    if (reply.error != null) {
-      throw reply.error
+    try {
+      await apiHandler(request, reply)
+      if (reply.error != null) throw reply.error
+    } catch (error) {
+      if (ctx.hasService(ENTRYPOINT_FAILURE_SERVICE)) {
+        await ctx.service<EntrypointFailureService>(ENTRYPOINT_FAILURE_SERVICE)
+          .notify({ alias: ep.alias, request, error })
+      }
+      throw error
     }
 
-    return [reply.value ?? null, reply.outcome ?? EntrypointOutcome.Ok]
-  }) as EntrypointCall<any>
+    return { value: reply.value ?? null, outcome: reply.outcome ?? EntrypointOutcome.Ok }
+  }) as EntrypointInvoke<any>
 
-export const urlCall: <
-  T, R extends ClientRequest = ClientRequest
->(ref: EntrypointRef<T, R>, opts?: ClientEntrypointOptions) => EntrypointCall<T, R> = ref => async (req, res) => {
-  const ep = ref.ref
-  if (ep == null) {
-    throw new SyntaxError('Try to make URL before the entrypoint is created')
-  }
-  const ctx = ep.ctx
-  if (ctx == null) {
-    throw new SyntaxError(`No context provided in urlCall for ${ep.alias} entrypoint`)
-  }
-  await ep.route.resolve(ctx)
-
-  const pathParams = extractParams(ep.getPath())
-  let path = pathParams.reduce((p, param) => {
-    return p.replace(`${PARAM}${param}`, `${req?.params?.[param as keyof typeof req.params]}`)
-  }, ep.getPath()) + (req?.query != null ? `?${stringify(req?.query)}` : '')
-
-  if (ep.route.route.service !== null && (
-    ctx.cfg.service !== ep.route.route.service
-    || req?.full === true)) {
-    const helper = makeSecurityHelper(ctx)
-    path = helper.makeUrl(
-      ep.route.route, path, { host: req?.host, base: req?.base, forceUnsecure: req?.unsecure }
-    )
-  }
+  const entrypointUrl = async (req?: Partial<R>, opts?: EntrypointUrlOptions): Promise<string> => {
+    const ep = ref.ref
+    if (ep == null) {
+      throw new SyntaxError('Try to make URL before the entrypoint is created')
+    }
+    const ctx = ep.ctx
+    if (ctx == null) {
+      throw new SyntaxError(`No context provided in entrypointUrl for ${ep.alias} entrypoint`)
+    }
 
-  res?.resolve(path as any, EntrypointOutcome.Ok)
+    // The base is left off here: an in-service URL is addressed relative to it, and the absolute
+    // branch below has `makeUrl` prepend it.
+    const epPath = ep.path()
+    const pathParams = clientRouteHelper.extractParams(epPath)
+    let path = pathParams.reduce((p, param) => {
+      return p.replace(`${PARAM}${param}`, `${req?.params?.[param as keyof typeof req.params]}`)
+    }, epPath) + (req?.query != null ? `?${stringify(req?.query)}` : '')
+
+    // A socket address is always absolute, whoever owns the route. `new WebSocket(path)` resolves a
+    // relative value against the PAGE's origin, which in a split deployment is the web host and not
+    // the service that answers the upgrade — so the handshake goes somewhere that never speaks it
+    // and dies on a gateway timeout. Only a same-origin HTTP route benefits from staying relative.
+    const socket = ep.route.route.protocol === RouteProtocols.SOCKET
+
+    // Locality is a question about the RESOLVED service, not about what the declaration happens to
+    // name: a route that names no service belongs to the asking context, and addressing it absolutely
+    // would turn in-app navigation into a full page load.
+    if (socket || !ep.isLocal() || opts?.absolute === true) {
+      const helper = makeSecurityHelper(ctx)
+      path = helper.makeUrl(
+        ep.address(), path, { host: req?.host, base: req?.base, forceUnsecure: req?.unsecure }
+      )
+    }
+
+    return path
+  }
 
-  return [path as any, EntrypointOutcome.Ok]
+  return { apiHandler, apiInvoke, entrypointUrl }
 }
+
+export const apiCallOf = memoHelper.oncePer(makeApiCallHelper)
+
+/** @deprecated compat:factory-refactor — use `makeApiCallHelper(ref).entrypointUrl(…)` */
+export const entrypointUrl = <T, R extends ClientRequest = ClientRequest>(
+  ref: EntrypointRef<T, R>, req?: Partial<R>, opts?: EntrypointUrlOptions
+): Promise<string> => makeApiCallHelper(ref).entrypointUrl(req, opts)

package/src/utils/index.ts

@@ -1,3 +1,4 @@
 
+export type * from './handler/types.js'
 export * from './entrypoint.js'
 export * from './handler.js'

package/src/utils/types.local.ts

@@ -0,0 +1,5 @@
+import type { ClientConfig, ClientContext } from '@owlmeans/client-context'
+
+export type Config = ClientConfig
+
+export interface Context<C extends Config = Config> extends ClientContext<C> { }