@occultist/occultist 0.0.4 → 0.0.6

package/lib/cache/types.ts

@@ -1,5 +1,5 @@
-import {ImplementedAction} from "../actions/types.js";
-import {CacheContext} from "../mod.js";
+import type {AuthState, ImplementedAction} from "../actions/types.ts";
+import type {CacheContext} from "../mod.ts";
 
 export type CacheStrategyType =
   | 'http'
@@ -7,15 +7,28 @@ export type CacheStrategyType =
   | 'store'
 ;
 
+export type CacheSemantics =
+  | 'options'
+  | 'head'
+  | 'get'
+  | 'post'
+  | 'put'
+  | 'delete'
+  | 'query'
+;
+
 export interface CacheEntryDescriptor {
   contentType: string;
+  semantics: CacheSemantics;
   action: ImplementedAction;
   request: Request;
   args: CacheInstanceArgs;
 };
 
-export type CacheWhenFn = (
-  ctx: CacheContext,
+export type CacheWhenFn<
+  Auth extends AuthState = AuthState,
+> = (
+  ctx: CacheContext<Auth>,
 ) => boolean;
 
 export type CacheRuleArgs = {
@@ -36,6 +49,11 @@ export type CacheRuleArgs = {
 
   varyOnCapabilities?: string | string[];
 
+  /**
+   * Overrides the semantics of the cache.
+   */
+  semantics?: CacheSemantics;
+
   /**
    * Defaults to false when a querystring is present
    * or the request is authenticated.
@@ -47,7 +65,7 @@ export type CacheRuleArgs = {
 
 export type CacheControlArgs = {
   private?: boolean;
-  public?: true;
+  publicWhenAuthenticated?: true;
   noCache?: true;
   noStore?: true;
   mustRevalidate?: true;
@@ -62,7 +80,6 @@ export type CacheControlArgs = {
 
 export type CacheHTTPArgs =
   & {
-    strategy: 'http';
     strong?: undefined;
     fromRequest?: undefined;
   }
@@ -77,7 +94,6 @@ export type CacheHTTPInstanceArgs =
 
 export type CacheETagArgs =
   & {
-    strategy: 'etag';
     strong?: boolean;
     fromRequest?: boolean;
     etag?: undefined;
@@ -88,12 +104,11 @@ export type CacheETagArgs =
 
 export type CacheETagInstanceArgs =
   & CacheETagArgs
-  & { stratey: 'etag', cache: CacheBuilder }
+  & { strategy: 'etag', cache: CacheBuilder }
 ;
 
 export type CacheStoreArgs =
   & {
-    strategy: 'store';
     strong?: boolean;
     fromRequest?: boolean;
     etag?: undefined;
@@ -120,7 +135,7 @@ export type CacheDetails = {
   hasContent: boolean;
   authKey: string;
   etag: string;
-  headers: Headers;
+  headers: Record<string, string | string[]>;
   contentType: string;
   contentLength?: number;
   contentEncoding?: string;
@@ -132,18 +147,18 @@ export type CacheHitHandle =
   & CacheDetails
   & {
     type: 'cache-hit';
-    set(details: CacheDetails): Promise<void>;
+    set(details: CacheDetails): void | Promise<void>;
   };
 
 export type CacheMissHandle = {
   type: 'cache-miss';
-  set(details: CacheDetails): Promise<void>;
+  set(details: CacheDetails): void | Promise<void>;
 };
 
 export type LockedCacheMissHandle = {
   type: 'locked-cache-miss';
-  set(details: CacheDetails): Promise<void>;
-  release(): Promise<void>;
+  set(details: CacheDetails): void | Promise<void>;
+  release(): void | Promise<void>;
 };
 
 
@@ -161,28 +176,50 @@ export interface CacheMeta {
   /**
    * Sets the cache details for a representation.
    *
-   * @param key       A unique key for this representation.
-   * @param details   The cache details.
+   * @param key Unique key for this cached value.
+   * @param details Details of the cache to store.
    */
   set(key: string, details: CacheDetails): void | Promise<void>;
 
   /**
    * Retrieves the cache details of a representation.
    *
-   * @param key       A unique key for this representation.
+   * @param key Unique key for this cached value.
    */
   get(key: string): CacheHitHandle | CacheMissHandle | Promise<CacheHitHandle | CacheMissHandle>;
 
   /**
    * Retrieves the cache details of a representation and takes a lock
-   * for update if the representation is not current.
+   * for update if the representation is not current. All concurrent requests
+   * targeting the same cached value will wait for the cache to be populated
+   * and respond from cache. This can occur across processes if the locking
+   * mechanism allows for it.
+   *
+   * This is an experimental API and its benifits are untested. APIs that
+   * have a high failure rate could see degredation in services as requests
+   * will queue to take the lock, but fail to set a new cache value causing
+   * the queued requests to continue locking.
    *
-   * Any other requests for this representation will wait for the request
-   * holding the lock to populate the cache before proceeding.
+   * However, this could help protect downstream services from thundering herd
+   * like scenarios as only one requester will build the representation that all
+   * requesters use.
    *
-   * @param key   A unique key for this representation.
+   * @param key Unique key for this cached value.
    */
   getOrLock?(key: string): Promise<CacheHitHandle | LockedCacheMissHandle>;
+
+  /**
+   * Invalidates a cached value by key.
+   *
+   * @param key Unique key for this cached value.
+   */
+  invalidate(key: string): void | Promise<void>;
+
+  /**
+   * Flushes the entire cache of values.
+   */
+  flush(): void | Promise<void>;
+
 }
 
 export interface UpstreamCache {
@@ -200,6 +237,7 @@ export interface UpstreamCache {
    * Invalidates a representation in the upstream cache.
    */
   invalidate(url: string): Promise<void>;
+
 };
 
 export interface CacheStorage {
@@ -215,9 +253,15 @@ export interface CacheStorage {
   set(key: string, data: Blob): void | Promise<void>;
 
   /**
-   * Invalidates a cache entry.
+   * Deletes a cache entry.
    */
   invalidate(key: string): void | Promise<void>;
+
+  /**
+   * Flushes the entire cache of values.
+   */
+  flush(): void | Promise<void>;
+
 };
 
 export interface CacheBuilder {
@@ -233,7 +277,10 @@ export interface CacheBuilder {
 
   store(args?: CacheStoreArgs): CacheInstanceArgs;
 
-  invalidate?(request: Request): Promise<void>;
+  /**
+   * Removes an item from the cache.
+   */
+  invalidate(key: string, url: string): void | Promise<void>;
 
   push?(request: Request): Promise<void>;
 }

package/lib/errors.ts

@@ -1,4 +1,4 @@
-import {ProblemDetails} from "./types.js";
+import type {ProblemDetails} from "./types.ts";
 
 // https://datatracker.ietf.org/doc/html/rfc9457
 export class ProblemDetailsError extends Error {

package/lib/jsonld.ts

@@ -1,4 +1,4 @@
-import type { ShallowMerge } from "./merge.js";
+import type { ShallowMerge } from "./merge.ts";
 
 // Union of numbers within our depth limit
 export type RecursiveDigit = 1 | 2 | 3 | 4 | 5 | 6 | 7;

package/lib/makeTypeDefs.ts

@@ -1,8 +1,8 @@
-import { joinPaths } from "./utils/joinPaths.js"
-import type { ContextDefinition, ContextDefinitionContainer, JSONLDContext, TypeDef } from "./jsonld.js";
-import type { Context } from "./actions/context.js";
-import { isPopulatedObject } from "./utils/isPopulatedObject.js";
-import { isPopulatedString } from "./utils/isPopulatedString.js";
+import { joinPaths } from "./utils/joinPaths.ts"
+import type { ContextDefinition, ContextDefinitionContainer, JSONLDContext, TypeDef } from "./jsonld.ts";
+import type { Context } from "./actions/context.ts";
+import { isPopulatedObject } from "./utils/isPopulatedObject.ts";
+import { isPopulatedString } from "./utils/isPopulatedString.ts";
 
 export type MakeTypeDefArgsFromType<Term extends string, Type extends string> =
   {

package/lib/mod.ts

@@ -1,15 +1,17 @@
-export * from './cache/types.js';
-export * from './cache/cache.js';
-export * from './cache/memory.js';
-export * from './cache/file.js';
-export * from './actions/types.js';
-export * from './actions/meta.js';
-export * from './actions/spec.js';
-export * from './actions/context.js';
-export * from './actions/path.js';
-export * from './actions/actions.js';
-export * from './actions/actionSets.js';
-export * from './registry.js';
-export * from './makeTypeDefs.js';
-export * from './utils/joinPaths.js';
-export * from './utils/contextBuilder.js';
+export * from './cache/types.ts';
+export * from './cache/cache.ts';
+export * from './cache/memory.ts';
+export * from './cache/file.ts';
+export * from './actions/types.ts';
+export * from './actions/meta.ts';
+export * from './actions/spec.ts';
+export * from './actions/context.ts';
+export * from './actions/path.ts';
+export * from './actions/actions.ts';
+export * from './actions/actionSets.ts';
+export * from './request.ts';
+export * from './actions/writer.ts';
+export * from './registry.ts';
+export * from './makeTypeDefs.ts';
+export * from './utils/joinPaths.ts';
+export * from './utils/contextBuilder.ts';

package/lib/processAction.ts

@@ -1,17 +1,17 @@
-import { JsonPointer } from 'json-ptr';
-import type { JSONValue } from "./jsonld.js";
-import { getInternalName } from "./utils/getInternalName.js";
-import { type BodyValue, getRequestBodyValues } from "./utils/getRequestBodyValues.js";
-import { type IRIValue, getRequestIRIValues } from "./utils/getRequestIRIValues.js";
-import { isNil } from "./utils/isNil.js";
-import { isObject } from "./utils/isObject.js";
-import { isPopulatedObject } from "./utils/isPopulatedObject.js";
-import { type ProblemDetailsParamsRefs, makeAppendProblemDetails } from "./utils/makeAppendProblemDetails.js";
-import { failsRequiredRequirement, failsTypeRequirement, failsContentTypeRequirement, failsMaxValue, failsMinValue, failsValueMinLength, failsValueMaxLength, failsStepValue, failsPatternValue, failsValidator, isObjectArraySpec, isObjectSpec, isArraySpec } from "./validators.js";
-import { InvalidActionParamsError, ProblemDetailsError } from "./errors.js";
-import { alwaysArray } from "./utils/alwaysArray.js";
-import type { ImplementedAction } from "./actions/types.js";
-import type { ActionPayload, ActionSpec, ArraySpec, ContextState, ObjectArraySpec, ObjectSpec, ParsedIRIValues, PropertySpec, SpecValue, ValueSpec } from "./actions/spec.js";
+import { JsonPointer } from "json-ptr";
+import { getInternalName } from "./utils/getInternalName.ts";
+import { type BodyValue, getRequestBodyValues } from "./utils/getRequestBodyValues.ts";
+import { type IRIValue, getRequestIRIValues } from "./utils/getRequestIRIValues.ts";
+import { isNil } from "./utils/isNil.ts";
+import { isObject } from "./utils/isObject.ts";
+import { isPopulatedObject } from "./utils/isPopulatedObject.ts";
+import { type ProblemDetailsParamsRefs, makeAppendProblemDetails } from "./utils/makeAppendProblemDetails.ts";
+import { failsRequiredRequirement, failsTypeRequirement, failsContentTypeRequirement, failsMaxValue, failsMinValue, failsValueMinLength, failsValueMaxLength, failsStepValue, failsPatternValue, failsValidator, isObjectArraySpec, isObjectSpec, isArraySpec } from "./validators.ts";
+import { InvalidActionParamsError, ProblemDetailsError } from "./errors.ts";
+import { alwaysArray } from "./utils/alwaysArray.ts";
+import type { ImplementedAction } from "./actions/types.ts";
+import type { ActionPayload, ActionSpec, ArraySpec, ContextState, ObjectArraySpec, ObjectSpec, ParsedIRIValues, PropertySpec, SpecValue, ValueSpec } from "./actions/spec.ts";
+import type {JSONValue} from "./jsonld.ts";
 
 
 

package/lib/registry.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { Registry } from './registry.js';
+import { Registry } from './registry.ts';
 import { createServer } from 'node:http';
 import type { AddressInfo } from 'node:net';
 

package/lib/registry.ts

@@ -1,15 +1,15 @@
-import { Accept } from "./accept.js";
-import { ActionAuth, HandlerDefinition } from "./actions/actions.js";
-import { type ActionMatchResult, ActionSet } from "./actions/actionSets.js";
-import { ActionMeta } from "./actions/meta.js";
-import type { ImplementedAction } from "./actions/types.js";
-import { ResponseWriter } from "./actions/writer.js";
-import { Scope } from './scopes.js';
+import { Accept } from "./accept.ts";
+import { ActionAuth, HandlerDefinition } from "./actions/actions.ts";
+import { type ActionMatchResult, ActionSet } from "./actions/actionSets.ts";
+import { ActionMeta } from "./actions/meta.ts";
+import type { CacheHitHeader, ImplementedAction } from "./actions/types.ts";
+import { ResponseWriter } from "./actions/writer.ts";
+import { Scope } from './scopes.ts';
 import { IncomingMessage, type ServerResponse } from "node:http";
-import type { Merge } from "./actions/spec.js";
-import type { ContextState, Middleware } from "./actions/spec.js";
-import {ProblemDetailsError} from "./errors.js"
-import {WrappedRequest} from "./request.js";
+import type { Merge } from "./actions/spec.ts";
+import type { ContextState, Middleware } from "./actions/spec.ts";
+import {ProblemDetailsError} from "./errors.ts"
+import {WrappedRequest} from "./request.ts";
 
 
 export interface Callable<
@@ -28,10 +28,6 @@ export class HTTP<
     this.#callable = callable;
   }
 
-  trace(name: string, path: string): ActionAuth<State> {
-    return this.#callable.method('trace', name, path);
-  }
-
   options(name: string, path: string): ActionAuth<State> {
     return this.#callable.method('options', name, path);
   }
@@ -60,6 +56,10 @@ export class HTTP<
     return this.#callable.method('delete', name, path);
   }
 
+  query(name: string, path: string): ActionAuth<State> {
+    return this.#callable.method('query', name, path);
+  }
+
 }
 
 
@@ -95,10 +95,79 @@ export type RegistryEvents =
 ;
 
 export type RegistryArgs = {
+
+  /**
+   * The public root endpoint the registry is bound to.
+   */
   rootIRI: string;
+
+  /**
+   * Set to `true` if a cache header should be added to the response when
+   * cache is successfully hit. Or assign custom header values.
+   */
+  cacheHitHeader?: CacheHitHeader;
+
+  /**
+   * Enables adding server timing headers to the response.
+   */
   serverTiming?: boolean;
 };
 
+/**
+ * All actions of an Occultist based API are created through an action registry.
+ * The registry exposes an interface for querying registered actions and emits events
+ * when userland actions have all been defined. Extensions can register themselves
+ * with the registry and create more actions and endpoints using the actions defined
+ * in userland. Userland code might also use the registry's querying functionality
+ * to programically make API calls as though they were made over the network via HTTP.
+ *
+ * @example <caption>Creates a simple registry that responds with a HTML document</caption>
+ *
+ * ```
+ * import {createServer} from 'node:http':
+ * import {Registry} from '@occultist/occultist';
+ * 
+ * const server = createServer();
+ * const registry = new Registry({ rootIRI: 'https://example.com' });
+ *
+ * registry.http.get('get-root', '/')
+ *   .handle('text/html', `
+ *     <!doctype html>
+ *     <html>
+ *       <head><title>Hello, World!</title></head>
+ *       <body>
+ *         <h1>Hello, World!</h1>
+ *       </body>
+ *     </body>
+ *   `);
+ *
+ * 
+ * server.on('request', (req, res) => registry.handleRequest(req, res));
+ * server.listen(3000);
+ *
+ * // makes a call programically to the registry
+ * const res = await registry.handleRequest(new Request('https://example.com'));
+ * ```
+ *
+ * @param args.rootIRI The public root endpoint the registry is bound to. If the
+ *   registry responds to requests on a subpath, the subpath should be included
+ *   in the `rootIRI` value.
+ *
+ * @param args.cacheHitHeader A custom cache hit header. If set to true Occultist
+ *   will use the standard `X-Cache` header and the value `HIT`. If a string is
+ *   provided the header name will be set to the value of the string. If an array
+ *   is provided the header name will be set to the first item in the array, and
+ *   the header value the second. Occultist does not set the cache header on
+ *   cache misses. By default Occultist will not set a cache hit header.
+ *
+ * @param args.serverTiming Enables server timing headers in responses. When
+ *   enabled requests log the duration of the steps Occultist takes when
+ *   finding the action to respond to the request, retrieving values from
+ *   cache, or calling the handler functions of an action. Browser debug tools
+ *   add these values to their network performance charts.
+ *   Enabling server timing can leak information and is not recommended for
+ *   production environments.
+ */
 export class Registry<
   State extends ContextState = ContextState,
 > implements Callable<State> {
@@ -107,6 +176,7 @@ export class Registry<
   #path: string;
   #rootIRI: string;
   #serverTiming: boolean;
+  #cacheHitHeader: CacheHitHeader;
   #http: HTTP<State>;
   #scopes: Scope[] = [];
   #children: ActionMeta[] = [];
@@ -123,6 +193,7 @@ export class Registry<
     this.#rootIRI = args.rootIRI;
     this.#path = url.pathname;
     this.#serverTiming = args.serverTiming ?? false;
+    this.#cacheHitHeader = args.cacheHitHeader ?? false;
     this.#http = new HTTP<State>(this);
   }
 
@@ -395,6 +466,10 @@ export class Registry<
     req: Request | IncomingMessage,
     res?: ServerResponse,
   ): Promise<Response | ServerResponse> {
+    if (!this.#finalized) {
+      this.finalize();
+    }
+
     const startTime = performance.now();
     const wrapped = new WrappedRequest(this.#rootIRI, req);
     const writer = new ResponseWriter(res);
@@ -415,12 +490,14 @@ export class Registry<
           req: wrapped,
           writer,
           startTime,
+          cacheHitHeader: this.#cacheHitHeader,
         });
       }
     } catch (err2) {
       if (err2 instanceof ProblemDetailsError) {
         err = err2;
       } else {
+        console.log(err2);
         err = new ProblemDetailsError(500, 'Internal server error');
       }
     }
@@ -430,17 +507,17 @@ export class Registry<
     }
       
     if (err instanceof ProblemDetailsError && req instanceof Request) {
-      return new Response(err.toContent('application/problem+json'), {
+      return new Response(err.toContent('application/problem.json'), {
         status: err.status,
         headers: {
-          'Content-Type': 'application/problem+json',
+          'Content-Type': 'application/problem.json',
         },
       });
     } else if (err instanceof ProblemDetailsError && res != null) {
       res.writeHead(err.status, {
-        'Content-Type': 'application/problem+json',
+        'Content-Type': 'application/problem.json',
       });
-      res.end(err.toContent('application/problem+json'));
+      res.end(err.toContent('application/problem.json'));
       return res;
     }
   }

package/lib/request.ts

@@ -1,6 +1,6 @@
 import {IncomingMessage} from "node:http";
 import {Readable} from "node:stream";
-import {normalizeURL} from "./utils/normalizeURL.js";
+import {normalizeURL} from "./utils/normalizeURL.ts";
 
 
 export class WrappedRequest implements Request {

package/lib/scopes.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { Registry } from "./registry.js";
-import { makeTypeDef, makeTypeDefs } from "./makeTypeDefs.js";
+import { Registry } from "./registry.ts";
+import { makeTypeDef, makeTypeDefs } from "./makeTypeDefs.ts";
 
 
 const typeDefs = makeTypeDefs([

package/lib/scopes.ts

@@ -1,10 +1,10 @@
-import { joinPaths } from "./utils/joinPaths.js";
-import { ActionAuth, HandlerDefinition } from "./actions/actions.js";
-import { ActionMeta } from "./actions/meta.js";
-import type { ContextState } from "./actions/spec.js";
-import type { ImplementedAction } from "./actions/types.js";
-import type { HTTPWriter } from "./actions/writer.js";
-import { type Callable, HTTP, type Registry } from './registry.js';
+import { joinPaths } from "./utils/joinPaths.ts"
+import { ActionAuth, HandlerDefinition } from "./actions/actions.ts";
+import { ActionMeta } from "./actions/meta.ts";
+import type { ContextState } from "./actions/spec.ts";
+import type { AuthMiddleware, ImplementedAction } from "./actions/types.ts";
+import type { HTTPWriter } from "./actions/writer.ts";
+import { type Callable, HTTP, type Registry } from './registry.ts';
 
 
 export type MetaPropatator = (meta: ActionMeta) => void;
@@ -28,6 +28,7 @@ export class Scope<
   #http: HTTP<State>;
   #children: Array<ActionMeta> = [];
   #public: boolean = true;
+  #auth: AuthMiddleware | undefined;
   #propergateMeta: (meta: ActionMeta) => void;
   
   constructor({
@@ -73,14 +74,16 @@ export class Scope<
     return this.actions.flatMap((action) => action.handlers);
   }
 
-  public(): Scope<State> {
+  public(authMiddleware?: AuthMiddleware): Scope<State> {
     this.#public = true;
+    this.#auth = authMiddleware;
 
     return this;
   }
 
-  private(): Scope<State> {
+  private(authMiddleware: AuthMiddleware): Scope<State> {
     this.#public = false;
+    this.#auth = authMiddleware;
 
     return this;
   }
@@ -161,13 +164,13 @@ export class Scope<
 
       if (this.#public) {
         this.#registry.http.get('scope-action', joinPaths(this.url(), action.name))
-          .public()
+          .public(this.#auth)
           .handle('application/ld+json', async (ctx) => {
             ctx.body = JSON.stringify(await action.jsonld());
           });
       } else {
         this.#registry.http.get('scope-action', joinPaths(this.url(), action.name))
-          .private()
+          .private(this.#auth)
           .handle('application/ld+json', async (ctx) => {
             ctx.body = JSON.stringify(await action.jsonld());
           });

package/lib/utils/contextBuilder.ts

@@ -1,6 +1,6 @@
-import type { JSONLDContext, ContextVersion, TypeDef } from "../jsonld.js";
-import { isNil } from "./isNil.js";
-import { isPopulatedObject } from "./isPopulatedObject.js";
+import type { JSONLDContext, ContextVersion, TypeDef } from "../jsonld.ts";
+import { isNil } from "./isNil.ts";
+import { isPopulatedObject } from "./isPopulatedObject.ts";
 
 export function contextBuilder({
   vocab,

package/lib/utils/getActionContext.ts

@@ -1,7 +1,7 @@
-import type { JSONLDContext, TypeDef } from "../jsonld.js";
-import { makeTypeDef, makeTypeDefs } from "../makeTypeDefs.js";
-import { contextBuilder } from "./contextBuilder.js";
-import type { ActionSpec, PropertySpec } from '../actions/spec.js';
+import type { JSONLDContext, TypeDef } from "../jsonld.ts";
+import { makeTypeDef, makeTypeDefs } from "../makeTypeDefs.ts";
+import { contextBuilder } from "./contextBuilder.ts";
+import type { ActionSpec, PropertySpec } from '../actions/spec.ts';
 
 const defaultTypeDefs = makeTypeDefs([
   makeTypeDef({ schema: 'https://schema.org/', term: 'Entrypoint' }),

package/lib/utils/getInternalName.ts

@@ -1,4 +1,4 @@
-import { isPopulatedString } from "./isPopulatedString.js";
+import { isPopulatedString } from "./isPopulatedString.ts";
 
 export function getInternalName({
   paramName,

package/lib/utils/getPropertyValueSpecifications.ts

@@ -1,7 +1,7 @@
-import type { OrArray, JSONValue } from "../jsonld.js";
-import type { ActionSpec, PropertySpec, ResponseInputSpec, SpecValue, ActionOption } from "../actions/spec.js";
-import { isNil } from "./isNil.js";
-import { isObject } from "./isObject.js";
+import type { OrArray, JSONValue } from "../jsonld.ts";
+import type { ActionSpec, PropertySpec, ResponseInputSpec, SpecValue, ActionOption } from "../actions/spec.ts";
+import { isNil } from "./isNil.ts";
+import { isObject } from "./isObject.ts";
 
 
 // deno-lint-ignore no-explicit-any

package/lib/utils/getRequestBodyValues.ts

@@ -1,8 +1,8 @@
-import { ProblemDetailsError } from "../errors.js";
-import type { JSONValue, ContextDefinition, JSONObject } from "../jsonld.js";
-import type { ContextState, ActionSpec, PropertySpec } from "../actions/spec.js";
-import jsonld from 'jsonld';
-import type { ImplementedAction } from "../actions/types.js";
+import { ProblemDetailsError } from "../errors.ts";
+import type { JSONValue, JSONObject } from "../jsonld.ts";
+import type { ContextState, ActionSpec, PropertySpec } from "../actions/spec.ts";
+import jsonld, {type ContextDefinition} from 'jsonld';
+import type { ImplementedAction } from "../actions/types.ts";
 
 
 // export type BodyValue = Record<string, FileInput | FileInput[] | JSONValue>;

package/lib/utils/getRequestIRIValues.ts

@@ -1,7 +1,7 @@
-import type { ImplementedAction } from "../actions/types.js";
-import { ProblemDetailsError } from "../errors.js";
-import type { ActionSpec, ContextState, FileSingleSpec, FileMultiSpec, BooleanSingleSpec, BooleanMultiSpec, NumberSingleSpec, NumberMultiSpec, StringSingleSpec, StringMultiSpec, ParsedIRIValues, PropertySpec } from "../actions/spec.js";
-import { getParamLocation } from "./getParamLocation.js";
+import type { ImplementedAction } from "../actions/types.ts";
+import { ProblemDetailsError } from "../errors.ts";
+import type { ActionSpec, ContextState, FileSingleSpec, FileMultiSpec, BooleanSingleSpec, BooleanMultiSpec, NumberSingleSpec, NumberMultiSpec, StringSingleSpec, StringMultiSpec, ParsedIRIValues, PropertySpec } from "../actions/spec.ts";
+import { getParamLocation } from "./getParamLocation.ts";
 
 
 export type IRIValue<