@occultist/occultist 0.0.7 → 0.0.9

package/dist/actions/actionSets.d.ts

@@ -1,5 +1,5 @@
 import { type Accept } from "../accept.ts";
-import type { ActionMeta } from "./meta.ts";
+import type { ActionCore } from "./core.ts";
 import type { ImplementedAction } from "./types.ts";
 export type UnsupportedContentTypeMatch = {
     type: 'unsupported-content-type';
@@ -18,6 +18,6 @@ export type ActionMatchResult = UnsupportedContentTypeMatch | ActionAcceptMatch;
  */
 export declare class ActionSet {
     #private;
-    constructor(rootIRI: string, method: string, path: string, meta: ActionMeta[]);
+    constructor(rootIRI: string, method: string, path: string, meta: ActionCore[]);
     matches(method: string, path: string, accept: Accept): null | ActionMatchResult;
 }

package/dist/actions/actions.d.ts

@@ -1,10 +1,10 @@
-import type { CacheInstanceArgs } from '../cache/types.ts';
+import type { CacheInstanceArgs, CacheOperationResult } from '../cache/types.ts';
 import type { JSONLDContext, JSONObject, TypeDef } from "../jsonld.ts";
 import type { Registry } from '../registry.ts';
 import type { Scope } from "../scopes.ts";
-import { type ActionMeta } from "./meta.ts";
+import { MiddlewareRefs, type ActionCore } from "./core.ts";
 import type { ActionSpec, ContextState } from "./spec.ts";
-import type { AuthMiddleware, AuthState, HandleRequestArgs, HandlerFn, HandlerMeta, HandlerObj, HandlerValue, HintArgs, ImplementedAction } from './types.ts';
+import type { AuthMiddleware, AuthState, HandlerFn, HandlerMeta, HandlerObj, HandlerValue, HintArgs, ImplementedAction } from './types.ts';
 import { type ResponseTypes } from './writer.ts';
 export type DefineArgs<Term extends string = string, Spec extends ActionSpec = ActionSpec> = {
     typeDef?: TypeDef<Term>;
@@ -21,7 +21,7 @@ export declare class HandlerDefinition<State extends ContextState = ContextState
     meta: HandlerMeta;
     action: ImplementedAction<State, Auth, Spec>;
     cache: ReadonlyArray<CacheInstanceArgs>;
-    constructor(name: string, contentType: string, handler: HandlerFn | HandlerValue, meta: HandlerMeta, action: ImplementedAction<State, Auth, Spec>, actionMeta: ActionMeta);
+    constructor(name: string, contentType: string, handler: HandlerFn | HandlerValue, meta: HandlerMeta, action: ImplementedAction<State, Auth, Spec>, actionMeta: ActionCore);
     get [Symbol.toStringTag](): string;
 }
 export interface Handleable<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec> {
@@ -36,9 +36,9 @@ export interface Handleable<State extends ContextState = ContextState, Auth exte
 }
 export declare class FinalizedAction<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec> implements Handleable<State, Auth, Spec>, ImplementedAction<State, Auth, Spec> {
     #private;
-    constructor(typeDef: TypeDef | undefined, spec: Spec, meta: ActionMeta<State, Auth, Spec>, handlerArgs: HandlerObj<State, Auth, Spec>);
-    static fromHandlers<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec>(typeDef: TypeDef | undefined, spec: Spec, meta: ActionMeta<State, Auth, Spec>, contextType: string | string[], handler: HandlerValue | HandlerFn<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
-    static fromHandlers<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec>(typeDef: TypeDef | undefined, spec: Spec, meta: ActionMeta<State, Auth, Spec>, handlerArgs: HandlerObj<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
+    constructor(typeDef: TypeDef | undefined, spec: Spec, core: ActionCore<State, Auth, Spec>, handlerArgs: HandlerObj<State, Auth, Spec>);
+    static fromHandlers<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec>(typeDef: TypeDef | undefined, spec: Spec, core: ActionCore<State, Auth, Spec>, contextType: string | string[], handler: HandlerValue | HandlerFn<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
+    static fromHandlers<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec>(typeDef: TypeDef | undefined, spec: Spec, core: ActionCore<State, Auth, Spec>, handlerArgs: HandlerObj<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
     static toJSONLD(action: ImplementedAction, scope: Scope): Promise<JSONObject | null>;
     get public(): boolean;
     get method(): string;
@@ -68,15 +68,17 @@ export declare class FinalizedAction<State extends ContextState = ContextState,
     } | null;
     handle(contentType: string | string[], handler: HandlerFn<State, Auth, Spec> | HandlerValue): FinalizedAction<State, Auth, Spec>;
     handle(args: HandlerObj<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
-    handleRequest(args: HandleRequestArgs): Promise<ResponseTypes>;
-    perform(req: Request): Promise<Response>;
+    handleRequest(refs: MiddlewareRefs<State, Auth, Spec>): Promise<ResponseTypes>;
+    primeCache(refs: MiddlewareRefs<State, Auth, Spec>): Promise<CacheOperationResult>;
+    refreshCache(refs: MiddlewareRefs<State, Auth, Spec>): Promise<CacheOperationResult>;
+    invalidateCache(refs: MiddlewareRefs<State, Auth, Spec>): Promise<CacheOperationResult>;
 }
 export interface Applicable<ActionType> {
     use(): ActionType;
 }
 export declare class DefinedAction<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Term extends string = string, Spec extends ActionSpec = ActionSpec> implements Applicable<DefinedAction<State, Auth, Term, Spec>>, Handleable<State, Auth, Spec>, ImplementedAction<State, Auth, Spec> {
     #private;
-    constructor(typeDef: TypeDef | undefined, spec: Spec, meta: ActionMeta<State, Auth, Spec>);
+    constructor(typeDef: TypeDef | undefined, spec: Spec, core: ActionCore<State, Auth, Spec>);
     get public(): boolean;
     get method(): string;
     get term(): string | undefined;
@@ -116,12 +118,14 @@ export declare class DefinedAction<State extends ContextState = ContextState, Au
     use(): DefinedAction<State, Auth, Term, Spec>;
     handle(contentType: string | string[], handler: HandlerValue | HandlerFn<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
     handle(args: HandlerObj<State, Auth, Spec>): FinalizedAction<State, Auth, Spec>;
-    handleRequest(args: HandleRequestArgs): Promise<ResponseTypes>;
-    perform(req: Request): Promise<Response>;
+    handleRequest(refs: MiddlewareRefs<State, Auth, Spec>): Promise<ResponseTypes>;
+    primeCache(refs: MiddlewareRefs<State, Auth, Spec>): Promise<CacheOperationResult>;
+    refreshCache(refs: MiddlewareRefs<State, Auth, Spec>): Promise<CacheOperationResult>;
+    invalidateCache(refs: MiddlewareRefs<State, Auth, Spec>): Promise<CacheOperationResult>;
 }
 export declare class Action<State extends ContextState = ContextState, Auth extends AuthState = AuthState> implements Applicable<Action>, Handleable<State>, ImplementedAction<State> {
     #private;
-    constructor(meta: ActionMeta<State>);
+    constructor(core: ActionCore<State>);
     get public(): boolean;
     get method(): string;
     get term(): string | undefined;
@@ -153,12 +157,14 @@ export declare class Action<State extends ContextState = ContextState, Auth exte
     define<Auth extends AuthState = AuthState, Term extends string = string, Spec extends ActionSpec = ActionSpec>(args: DefineArgs<Term, Spec>): DefinedAction<State, Auth, Term, Spec>;
     handle(contentType: string | string[], handler: HandlerValue | HandlerFn<State>): FinalizedAction<State>;
     handle(args: HandlerObj<State>): FinalizedAction<State>;
-    handleRequest(args: HandleRequestArgs): Promise<ResponseTypes>;
-    perform(req: Request): Promise<Response>;
+    handleRequest(refs: MiddlewareRefs<State, Auth, ActionSpec>): Promise<ResponseTypes>;
+    primeCache(refs: MiddlewareRefs<State, Auth, ActionSpec>): Promise<CacheOperationResult>;
+    refreshCache(refs: MiddlewareRefs<State, Auth, ActionSpec>): Promise<CacheOperationResult>;
+    invalidateCache(refs: MiddlewareRefs<State, Auth, ActionSpec>): Promise<CacheOperationResult>;
 }
 export declare class PreAction<State extends ContextState = ContextState, Auth extends AuthState = AuthState> implements Applicable<Action>, Handleable<State, Auth> {
     #private;
-    constructor(meta: ActionMeta<State, Auth>);
+    constructor(core: ActionCore<State, Auth>);
     use(): Action<State, AuthState>;
     define<Term extends string = string, Spec extends ActionSpec = ActionSpec>(args: DefineArgs<Term, Spec>): DefinedAction<State, Auth, Term, Spec>;
     handle(contentType: string | string[], handler: HandlerValue | HandlerFn<State, Auth>): FinalizedAction<State, Auth>;
@@ -166,7 +172,7 @@ export declare class PreAction<State extends ContextState = ContextState, Auth e
 }
 export declare class Endpoint<State extends ContextState = ContextState, Auth extends AuthState = AuthState> implements Applicable<Action>, Handleable<State, Auth> {
     #private;
-    constructor(meta: ActionMeta<State, Auth>);
+    constructor(core: ActionCore<State, Auth>);
     hint(hints: HintArgs): Endpoint<State, Auth>;
     compress(): Endpoint<State, Auth>;
     cache(args: CacheInstanceArgs): Endpoint<State, Auth>;
@@ -178,7 +184,7 @@ export declare class Endpoint<State extends ContextState = ContextState, Auth ex
 }
 export declare class ActionAuth<State extends ContextState = ContextState> {
     #private;
-    constructor(meta: ActionMeta<State>);
+    constructor(core: ActionCore<State>);
     public<Auth extends AuthState = AuthState>(authMiddleware?: AuthMiddleware<Auth>): Endpoint<State, Auth>;
     private<Auth extends AuthState = AuthState>(authMiddleware: AuthMiddleware<Auth>): Endpoint<State, Auth>;
 }

package/dist/actions/actions.js

@@ -2,7 +2,7 @@ import { getActionContext } from "../utils/getActionContext.js";
 import { getPropertyValueSpecifications } from "../utils/getPropertyValueSpecifications.js";
 import { isPopulatedObject } from "../utils/isPopulatedObject.js";
 import { joinPaths } from "../utils/joinPaths.js";
-import { AfterDefinition, BeforeDefinition } from "./meta.js";
+import { AfterDefinition, BeforeDefinition } from "./core.js";
 function isHandlerObj(handler) {
     return isPopulatedObject(handler);
 }
@@ -36,33 +36,33 @@ export class HandlerDefinition {
 }
 export class FinalizedAction {
     #spec;
-    #meta;
+    #core;
     #typeDef;
     #handlers;
-    constructor(typeDef, spec, meta, handlerArgs) {
+    constructor(typeDef, spec, core, handlerArgs) {
         this.#typeDef = typeDef;
         this.#spec = spec ?? {};
-        this.#meta = meta;
-        this.#meta.action = this;
+        this.#core = core;
+        this.#core.action = this;
         const handlers = new Map();
         if (typeof handlerArgs.contentType === 'string') {
-            handlers.set(handlerArgs.contentType, new HandlerDefinition(this.name, handlerArgs.contentType, handlerArgs.handler, handlerArgs.meta, this, this.#meta));
+            handlers.set(handlerArgs.contentType, new HandlerDefinition(this.name, handlerArgs.contentType, handlerArgs.handler, handlerArgs.meta, this, this.#core));
         }
         else if (isPopulatedObject(handlerArgs)) {
             for (let i = 0; i < handlerArgs.contentType.length; i++) {
-                handlers.set(handlerArgs.contentType[i], new HandlerDefinition(this.name, handlerArgs.contentType[i], handlerArgs.handler, handlerArgs.meta, this, this.#meta));
+                handlers.set(handlerArgs.contentType[i], new HandlerDefinition(this.name, handlerArgs.contentType[i], handlerArgs.handler, handlerArgs.meta, this, this.#core));
             }
         }
         this.#handlers = handlers;
     }
-    static fromHandlers(typeDef, spec, meta, arg3, arg4) {
+    static fromHandlers(typeDef, spec, core, arg3, arg4) {
         if (Array.isArray(arg3) || typeof arg3 === 'string') {
-            return new FinalizedAction(typeDef, spec, meta, {
+            return new FinalizedAction(typeDef, spec, core, {
                 contentType: arg3,
                 handler: arg4,
             });
         }
-        return new FinalizedAction(typeDef, spec, meta, arg3);
+        return new FinalizedAction(typeDef, spec, core, arg3);
     }
     static async toJSONLD(action, scope) {
         if (scope == null || action.typeDef == null) {
@@ -83,10 +83,10 @@ export class FinalizedAction {
         };
     }
     get public() {
-        return this.#meta.public;
+        return this.#core.public;
     }
     get method() {
-        return this.#meta.method;
+        return this.#core.method;
     }
     get term() {
         return this.#typeDef?.term;
@@ -98,22 +98,22 @@ export class FinalizedAction {
         return this.#typeDef;
     }
     get name() {
-        return this.#meta.name;
+        return this.#core.name;
     }
     get template() {
-        return this.#meta.uriTemplate;
+        return this.#core.uriTemplate;
     }
     get pattern() {
-        return this.#meta.path.pattern;
+        return this.#core.path.pattern;
     }
     get spec() {
         return this.#spec;
     }
     get scope() {
-        return this.#meta.scope;
+        return this.#core.scope;
     }
     get registry() {
-        return this.#meta.registry;
+        return this.#core.registry;
     }
     get handlers() {
         return Array.from(this.#handlers.values());
@@ -129,7 +129,7 @@ export class FinalizedAction {
         });
     }
     url() {
-        return joinPaths(this.#meta.registry.rootIRI, this.#meta.path.normalized);
+        return joinPaths(this.#core.registry.rootIRI, this.#core.path.normalized);
     }
     /**
      * Retrives the handler configured for the given content type.
@@ -140,18 +140,18 @@ export class FinalizedAction {
         return this.#handlers.get(contentType);
     }
     jsonld() {
-        const scope = this.#meta.scope;
+        const scope = this.#core.scope;
         return FinalizedAction.toJSONLD(this, scope);
     }
     jsonldPartial() {
-        const scope = this.#meta.scope;
+        const scope = this.#core.scope;
         const typeDef = this.#typeDef;
         if (scope == null || typeDef == null) {
             return null;
         }
         return {
             '@type': typeDef.type,
-            '@id': joinPaths(scope.url(), this.#meta.name),
+            '@id': joinPaths(scope.url(), this.#core.name),
         };
     }
     handle(arg1, arg2) {
@@ -174,42 +174,55 @@ export class FinalizedAction {
             meta = Object.create(null);
         }
         if (!Array.isArray(contentType)) {
-            this.#handlers.set(contentType, new HandlerDefinition(this.#meta.name, contentType, handler, meta, this, this.#meta));
+            this.#handlers.set(contentType, new HandlerDefinition(this.#core.name, contentType, handler, meta, this, this.#core));
         }
         else {
             for (let i = 0; i < contentType.length; i++) {
-                this.#handlers.set(contentType[i], new HandlerDefinition(this.#meta.name, contentType[i], handler, meta, this, this.#meta));
+                this.#handlers.set(contentType[i], new HandlerDefinition(this.#core.name, contentType[i], handler, meta, this, this.#core));
             }
         }
         return this;
     }
-    handleRequest(args) {
-        const handler = this.#handlers.get(args.contentType);
-        return this.#meta.handleRequest({
-            ...args,
-            spec: this.#spec,
-            handler,
-        });
-    }
-    perform(req) {
-        return this.#meta.perform(req);
+    handleRequest(refs) {
+        const handler = this.#handlers.get(refs.contentType);
+        refs.spec = this.#spec;
+        refs.handler = handler;
+        return this.#core.handleRequest(refs);
+    }
+    primeCache(refs) {
+        const handler = this.#handlers.get(refs.contentType);
+        refs.spec = this.#spec;
+        refs.handler = handler;
+        return this.#core.primeCache(refs);
+    }
+    refreshCache(refs) {
+        const handler = this.#handlers.get(refs.contentType);
+        refs.spec = this.#spec;
+        refs.handler = handler;
+        return this.#core.refreshCache(refs);
+    }
+    invalidateCache(refs) {
+        const handler = this.#handlers.get(refs.contentType);
+        refs.spec = this.#spec;
+        refs.handler = handler;
+        return this.#core.invalidateCache(refs);
     }
 }
 export class DefinedAction {
     #spec;
-    #meta;
+    #core;
     #typeDef;
-    constructor(typeDef, spec, meta) {
+    constructor(typeDef, spec, core) {
         this.#spec = spec ?? {};
-        this.#meta = meta;
+        this.#core = core;
         this.#typeDef = typeDef;
-        this.#meta.action = this;
+        this.#core.action = this;
     }
     get public() {
-        return this.#meta.public;
+        return this.#core.public;
     }
     get method() {
-        return this.#meta.method;
+        return this.#core.method;
     }
     get term() {
         return this.#typeDef?.term;
@@ -221,25 +234,25 @@ export class DefinedAction {
         return this.#typeDef;
     }
     get name() {
-        return this.#meta.name;
+        return this.#core.name;
     }
     get template() {
-        return this.#meta.uriTemplate;
+        return this.#core.uriTemplate;
     }
     get pattern() {
-        return this.#meta.path.pattern;
+        return this.#core.path.pattern;
     }
     get path() {
-        return this.#meta.path.normalized;
+        return this.#core.path.normalized;
     }
     get spec() {
         return this.#spec;
     }
     get scope() {
-        return this.#meta.scope;
+        return this.#core.scope;
     }
     get registry() {
-        return this.#meta.registry;
+        return this.#core.registry;
     }
     get handlers() {
         return [];
@@ -264,18 +277,18 @@ export class DefinedAction {
         });
     }
     jsonld() {
-        const scope = this.#meta.scope;
+        const scope = this.#core.scope;
         return FinalizedAction.toJSONLD(this, scope);
     }
     jsonldPartial() {
-        const scope = this.#meta.scope;
+        const scope = this.#core.scope;
         const typeDef = this.#typeDef;
         if (scope == null || typeDef == null) {
             return null;
         }
         return {
             '@type': typeDef.type,
-            '@id': joinPaths(scope.url(), this.#meta.name),
+            '@id': joinPaths(scope.url(), this.#core.name),
         };
     }
     /**
@@ -286,15 +299,15 @@ export class DefinedAction {
      * auth sensitive checks to be run which might reject the request.
      */
     cache(args) {
-        if (this.#meta.cache.length !== 0 &&
-            this.#meta.cacheOccurance === BeforeDefinition) {
+        if (this.#core.cache.length !== 0 &&
+            this.#core.cacheOccurance === BeforeDefinition) {
             throw new Error('Action cache may be defined either before or after ' +
                 'the definition method is called, but not both.');
         }
-        else if (this.#meta.cacheOccurance === BeforeDefinition) {
-            this.#meta.cacheOccurance = AfterDefinition;
+        else if (this.#core.cacheOccurance === BeforeDefinition) {
+            this.#core.cacheOccurance = AfterDefinition;
         }
-        this.#meta.cache.push(args);
+        this.#core.cache.push(args);
         return this;
     }
     meta() {
@@ -304,30 +317,37 @@ export class DefinedAction {
         return this;
     }
     handle(arg1, arg2) {
-        return FinalizedAction.fromHandlers(this.#typeDef, this.#spec, this.#meta, arg1, arg2);
+        return FinalizedAction.fromHandlers(this.#typeDef, this.#spec, this.#core, arg1, arg2);
     }
-    async handleRequest(args) {
-        return this.#meta.handleRequest({
-            ...args,
-            spec: this.#spec,
-        });
+    handleRequest(refs) {
+        refs.spec = this.#spec;
+        return this.#core.handleRequest(refs);
+    }
+    primeCache(refs) {
+        refs.spec = this.#spec;
+        return this.#core.primeCache(refs);
     }
-    perform(req) {
-        return this.#meta.perform(req);
+    refreshCache(refs) {
+        refs.spec = this.#spec;
+        return this.#core.refreshCache(refs);
+    }
+    invalidateCache(refs) {
+        refs.spec = this.#spec;
+        return this.#core.invalidateCache(refs);
     }
 }
 export class Action {
     #spec = {};
-    #meta;
-    constructor(meta) {
-        this.#meta = meta;
-        this.#meta.action = this;
+    #core;
+    constructor(core) {
+        this.#core = core;
+        this.#core.action = this;
     }
     get public() {
-        return this.#meta.public;
+        return this.#core.public;
     }
     get method() {
-        return this.#meta.method;
+        return this.#core.method;
     }
     get term() {
         return undefined;
@@ -339,25 +359,25 @@ export class Action {
         return undefined;
     }
     get name() {
-        return this.#meta.name;
+        return this.#core.name;
     }
     get template() {
-        return this.#meta.uriTemplate;
+        return this.#core.uriTemplate;
     }
     get pattern() {
-        return this.#meta.path.pattern;
+        return this.#core.path.pattern;
     }
     get path() {
-        return this.#meta.path.normalized;
+        return this.#core.path.normalized;
     }
     get spec() {
         return this.#spec;
     }
     get scope() {
-        return this.#meta.scope;
+        return this.#core.scope;
     }
     get registry() {
-        return this.#meta.registry;
+        return this.#core.registry;
     }
     get handlers() {
         return [];
@@ -391,81 +411,88 @@ export class Action {
         return this;
     }
     define(args) {
-        return new DefinedAction(args.typeDef, args.spec ?? {}, this.#meta);
+        return new DefinedAction(args.typeDef, args.spec ?? {}, this.#core);
     }
     handle(arg1, arg2) {
-        return FinalizedAction.fromHandlers(null, this.#spec, this.#meta, arg1, arg2);
+        return FinalizedAction.fromHandlers(null, this.#spec, this.#core, arg1, arg2);
     }
-    async handleRequest(args) {
-        return this.#meta.handleRequest({
-            ...args,
-            spec: this.#spec,
-        });
+    handleRequest(refs) {
+        refs.spec = this.#spec;
+        return this.#core.handleRequest(refs);
+    }
+    primeCache(refs) {
+        refs.spec = this.#spec;
+        return this.#core.primeCache(refs);
+    }
+    refreshCache(refs) {
+        refs.spec = this.#spec;
+        return this.#core.refreshCache(refs);
     }
-    perform(req) {
-        return this.#meta.perform(req);
+    invalidateCache(refs) {
+        refs.spec = this.#spec;
+        return this.#core.refreshCache(refs);
     }
 }
 export class PreAction {
-    #meta;
-    constructor(meta) {
-        this.#meta = meta;
+    #core;
+    constructor(core) {
+        this.#core = core;
     }
     use() {
-        return new Action(this.#meta);
+        return new Action(this.#core);
     }
     define(args) {
-        return new DefinedAction(args.typeDef, args.spec, this.#meta);
+        return new DefinedAction(args.typeDef, args.spec, this.#core);
     }
     handle(arg1, arg2) {
-        return FinalizedAction.fromHandlers(null, {}, this.#meta, arg1, arg2);
+        return FinalizedAction.fromHandlers(null, {}, this.#core, arg1, arg2);
     }
 }
 export class Endpoint {
-    #meta;
-    constructor(meta) {
-        this.#meta = meta;
+    #core;
+    constructor(core) {
+        this.#core = core;
     }
     hint(hints) {
-        this.#meta.hints.push(hints);
+        this.#core.hints.push(hints);
         return this;
     }
     compress() {
         return this;
     }
     cache(args) {
-        this.#meta.cache.push(args);
+        this.#core.cache.push(args);
         return this;
     }
     etag() {
         return this;
     }
     use() {
-        return new Action(this.#meta);
+        return new Action(this.#core);
     }
     define(args) {
-        return new DefinedAction(args.typeDef, args.spec, this.#meta);
+        return new DefinedAction(args.typeDef, args.spec, this.#core);
     }
     handle(arg1, arg2) {
-        return FinalizedAction.fromHandlers(undefined, {}, this.#meta, arg1, arg2);
+        return FinalizedAction.fromHandlers(undefined, {}, this.#core, arg1, arg2);
     }
 }
 export class ActionAuth {
-    #meta;
-    constructor(meta) {
-        this.#meta = meta;
+    #core;
+    constructor(core) {
+        this.#core = core;
     }
     public(authMiddleware) {
         if (authMiddleware != null && typeof authMiddleware !== 'function')
             throw new Error('Public action given invalid auth middleware');
-        this.#meta.public = true;
-        this.#meta.auth = authMiddleware;
-        return new Endpoint(this.#meta);
+        this.#core.public = true;
+        this.#core.auth = authMiddleware;
+        return new Endpoint(this.#core);
     }
     private(authMiddleware) {
         if (typeof authMiddleware !== 'function')
             throw new Error('Private action given invalid auth middleware');
-        this.#meta.auth = authMiddleware;
-        return new Endpoint(this.#meta);
+        this.#core.auth = authMiddleware;
+        return new Endpoint(this.#core);
     }
 }

package/dist/actions/context.d.ts

@@ -1,18 +1,19 @@
-import type { HandlerDefinition } from "../mod.ts";
+import type { CacheOperation, HandlerDefinition } from "../mod.ts";
 import type { Registry } from "../registry.ts";
 import type { ActionPayload, ActionSpec, ContextState, ParsedIRIValues } from "./spec.ts";
 import type { AuthState, ImplementedAction } from "./types.ts";
 import type { ResponseBody } from "./writer.ts";
 export type CacheContextArgs<Auth extends AuthState = AuthState> = {
     req: Request;
-    url: string;
     contentType: string;
     public: boolean;
     authKey?: string;
     auth: Auth;
+    cacheOperation?: CacheOperation;
     handler: HandlerDefinition;
     params: ParsedIRIValues;
     query: ParsedIRIValues;
+    headers: Headers;
 };
 /**
  * Request context object.
@@ -24,8 +25,10 @@ export declare class CacheContext<Auth extends AuthState = AuthState> {
     url: string;
     contentType: string;
     public: boolean;
-    authKey?: string;
+    authKey: string | null;
     auth: Auth;
+    cacheRun: boolean;
+    cacheOperation: CacheOperation | null;
     action: ImplementedAction;
     registry: Registry;
     params: ParsedIRIValues;
@@ -44,15 +47,16 @@ export declare class CacheContext<Auth extends AuthState = AuthState> {
 }
 export type ContextArgs<State extends ContextState = ContextState, Auth extends AuthState = AuthState, Spec extends ActionSpec = ActionSpec> = {
     req: Request;
-    url: string;
     contentType: string;
     public: boolean;
     authKey?: string;
     auth: Auth;
-    handler: HandlerDefinition<State, Spec>;
+    cacheOperation: CacheOperation | null;
+    handler: HandlerDefinition<State, Auth, Spec>;
     params: ParsedIRIValues;
     query: ParsedIRIValues;
     payload: ActionPayload<Spec>;
+    headers: Headers;
 };
 /**
  * Request context object.
@@ -66,8 +70,10 @@ export declare class Context<State extends ContextState = ContextState, Auth ext
     public: boolean;
     authKey?: string;
     auth: Auth;
+    cacheRun: boolean;
+    cacheOperation: CacheOperation | null;
     state: State;
-    action: ImplementedAction<State, Spec>;
+    action: ImplementedAction<State, Auth, Spec>;
     registry: Registry;
     params: ParsedIRIValues;
     query: ParsedIRIValues;