@owlmeans/client-entrypoint 0.1.18-rc.45 → 0.1.18-rc.47

package/src/utils/handler.ts

@@ -1,68 +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, EntrypointTransport } from '@owlmeans/entrypoint'
-import { EntrypointOutcome, provideResponse, transportAlias } from '@owlmeans/entrypoint'
-import type { ClientEntrypoint, EntrypointInvoke, EntrypointUrlOptions, 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 { 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 '../failure.js'
-import type { EntrypointFailureService } from '../failure.js'
+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')
 
-type Config = ClientConfig
-interface Context<C extends Config = Config> extends ClientContext<C> { }
+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)
 
-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)
-
-  if (context.cfg.webService == null) {
-    throw new SyntaxError('No webService provided')
-  }
+    if (context.cfg.webService == null) {
+      throw new SyntaxError('No webService provided')
+    }
 
-  const ep = context.entrypoint<ClientEntrypoint>(req.alias)
+    const ep = context.entrypoint<ClientEntrypoint>(req.alias)
 
-  // 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()
+    // 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()
 
-    return context.service<EntrypointTransport>(transport).handle(req, res)
-  }
+      return context.service<EntrypointTransport>(transport).handle(req, res)
+    }
 
-  // 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()
+    // 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()
 
-  const alias: string | undefined = typeof context.cfg.webService === 'string'
-    ? context.cfg.webService
-    : context.cfg.webService[route.service] ?? 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.path()
+    req.path = ep.path()
 
-  return service.handler(req, res as any)
-}
+    return service.handler(req, res as any)
+  }
 
-export const apiInvoke: <
-  T, R extends AbstractRequest = AbstractRequest
->(ref: EntrypointRef<T, R>, opts?: ClientEntrypointOptions) => EntrypointInvoke<T, R> =
-  (ref, opts) => (async (req) => {
+  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')
@@ -112,7 +106,7 @@ export const apiInvoke: <
       throw new SyntaxError(`Use entrypoint ${ep.alias} without context`)
     }
     try {
-      await apiHandler(ref)(request, reply)
+      await apiHandler(request, reply)
       if (reply.error != null) throw reply.error
     } catch (error) {
       if (ctx.hasService(ENTRYPOINT_FAILURE_SERVICE)) {
@@ -125,41 +119,49 @@ export const apiInvoke: <
     return { value: reply.value ?? null, outcome: reply.outcome ?? EntrypointOutcome.Ok }
   }) as EntrypointInvoke<any>
 
-export const entrypointUrl: <
-  T, R extends ClientRequest = ClientRequest
->(ref: EntrypointRef<T, R>, req?: Partial<R>, opts?: EntrypointUrlOptions) => Promise<string> = async (ref, req, opts) => {
-  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`)
-  }
+  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`)
+    }
+
+    // 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 }
+      )
+    }
 
-  // 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 = 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
+  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> { }