@occultist/occultist 0.0.1

package/dist/scopes.js

@@ -0,0 +1,121 @@
+import { joinPaths } from "./utils/joinPaths.js";
+import { ActionAuth } from "./actions/actions.js";
+import { ActionMeta } from "./actions/meta.js";
+import { HTTP } from './registry.js';
+export class Scope {
+    #path;
+    #serverTiming = false;
+    #registry;
+    #writer;
+    #http;
+    #children = [];
+    #public = true;
+    #propergateMeta;
+    constructor({ path, serverTiming, registry, writer, propergateMeta, }) {
+        this.#path = path;
+        this.#serverTiming = serverTiming;
+        this.#registry = registry;
+        this.#writer = writer;
+        this.#http = new HTTP(this);
+        this.#propergateMeta = propergateMeta;
+    }
+    get path() {
+        return this.#path;
+    }
+    get registry() {
+        return this.#registry;
+    }
+    get http() {
+        return this.#http;
+    }
+    get actions() {
+        return this.#children
+            .filter((meta) => {
+            if (meta.action == null) {
+                console.warn(`Action ${meta.method}: ${meta.path} not fully implemented before processing`);
+            }
+            return meta.action != null;
+        })
+            .map((meta) => meta.action);
+    }
+    get handlers() {
+        return this.actions.flatMap((action) => action.handlers);
+    }
+    public() {
+        this.#public = true;
+        return this;
+    }
+    private() {
+        this.#public = false;
+        return this;
+    }
+    /**
+     * Creates any HTTP method.
+     *
+     * @param method The HTTP method.
+     * @param name   Name for the action being produced.
+     * @param path   Path the action responds to.
+     */
+    method(method, name, path) {
+        const meta = new ActionMeta(this.#registry.rootIRI, method.toUpperCase(), name, path, this.#registry, this.#writer, this);
+        meta.serverTiming = this.#serverTiming;
+        this.#children.push(meta);
+        this.#propergateMeta(meta);
+        return new ActionAuth(meta);
+    }
+    url() {
+        return joinPaths(this.#registry.rootIRI, this.#path);
+    }
+    finalize() {
+        const partials = {
+            '@id': this.url(),
+            '@container': '@type',
+        };
+        for (let index = 0; index < this.#children.length; index++) {
+            const meta = this.#children[index];
+            const action = meta.action;
+            if (action == null || action.type == null) {
+                continue;
+            }
+            const partial = action.jsonldPartial();
+            if (partial == null) {
+                continue;
+            }
+            partials[partial['@type']] = partial;
+        }
+        if (this.#public) {
+            this.#registry.http.get('scope', this.#path)
+                .public()
+                .handle('application/ld+json', (ctx) => {
+                ctx.body = JSON.stringify(partials);
+            });
+        }
+        else {
+            this.#registry.http.get('scope', this.#path)
+                .public()
+                .handle('application/ld+json', (ctx) => {
+                ctx.body = JSON.stringify(partials);
+            });
+        }
+        for (let index = 0; index < this.#children.length; index++) {
+            const action = this.#children[index].action;
+            if (action == null || action.type == null) {
+                continue;
+            }
+            if (this.#public) {
+                this.#registry.http.get('scope-action', joinPaths(this.url(), action.name))
+                    .public()
+                    .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()
+                    .handle('application/ld+json', async (ctx) => {
+                    ctx.body = JSON.stringify(await action.jsonld());
+                });
+            }
+        }
+    }
+}

package/dist/scopes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scopes.test.js

@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { Registry } from "./registry.js";
+import { makeTypeDef, makeTypeDefs } from "./makeTypeDefs.js";
+const typeDefs = makeTypeDefs([
+    makeTypeDef('GetThing', 'https://schema.example.com/'),
+    makeTypeDef('name', 'https://schema.org/'),
+    makeTypeDef('description', 'https://schema.org/'),
+]);
+const registry = new Registry({
+    rootIRI: 'https://example.com',
+});
+const scope = registry.scope('/actions')
+    .public();
+scope.http.get('get-thing', '/thing')
+    .public()
+    .define({
+    typeDef: typeDefs.GetThing,
+    spec: {
+        name: {
+            typeDef: typeDefs.name,
+            valueMinLength: 3,
+            valueRequired: true,
+        },
+        description: {
+            type: 'https://schema.org/description',
+            valueRequired: false,
+        },
+    },
+});
+registry.finalize();
+test('It responds with actions partials as a jsonld type map', async () => {
+    const res = await registry.handleRequest(new Request('https://example.com/actions'));
+    const body = await res.json();
+    assert.deepEqual(body[typeDefs.GetThing.type], {
+        '@type': typeDefs.GetThing.type,
+        '@id': 'https://example.com/actions/get-thing',
+    });
+});
+test('It responds with actions partials as a jsonld type map', async () => {
+    const res = await registry.handleRequest(new Request('https://example.com/actions/get-thing'));
+    const body = await res.json();
+    // compacted representation is returned
+    assert.equal(body['@id'], 'https://example.com/actions/get-thing');
+    assert.equal(body['@type'], typeDefs.GetThing.term);
+    assert.deepEqual(body[`${typeDefs.name.term}-input`], {
+        '@type': 'https://schema.org/PropertyValueSpecification',
+        valueRequired: true,
+        valueMinLength: 3,
+    });
+    assert.deepEqual(body[`${typeDefs.description.term}-input`], {
+        '@type': 'https://schema.org/PropertyValueSpecification',
+        valueRequired: false,
+    });
+});

package/dist/transformers/fileTransformer.d.ts

@@ -0,0 +1 @@
+export declare function fileTransformer(value: File | string): Promise<File | Blob>;

package/dist/transformers/fileTransformer.js

@@ -0,0 +1,8 @@
+export async function fileTransformer(value) {
+    if (typeof value === 'string') {
+        return fetch(value)
+            .then((res) => res.blob())
+            .catch(() => Promise.reject('Invalid data url'));
+    }
+    return value;
+}

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+export type ProblemDetailsParam = {
+    name: string;
+    reason: string;
+    pointer?: string;
+};
+export type ProblemDetails = {
+    title: string;
+    type?: string;
+    detail?: string;
+    instance?: string;
+    errors?: Array<ProblemDetailsParam>;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/alwaysArray.d.ts

@@ -0,0 +1 @@
+export declare function alwaysArray<T>(value: T | Array<T>): Array<T>;

package/dist/utils/alwaysArray.js

@@ -0,0 +1,9 @@
+export function alwaysArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== 'undefined' && value !== null) {
+        return [value];
+    }
+    return [];
+}

package/dist/utils/contextBuilder.d.ts

@@ -0,0 +1,9 @@
+import type { JSONLDContext, ContextVersion, TypeDef } from "../jsonld.js";
+export declare function contextBuilder({ vocab, version, protect, idTerm, aliases, typeDefs: argsTypeDefs, }: {
+    idTerm?: string;
+    vocab?: string;
+    version?: ContextVersion;
+    protect?: boolean;
+    aliases?: Record<string, string>;
+    typeDefs?: Record<string, TypeDef> | Array<TypeDef>;
+}): JSONLDContext;

package/dist/utils/contextBuilder.js

@@ -0,0 +1,82 @@
+import { isNil } from "./isNil.js";
+import { isPopulatedObject } from "./isPopulatedObject.js";
+export function contextBuilder({ vocab, version = 1.1, protect = false, idTerm, aliases, typeDefs: argsTypeDefs, }) {
+    let typeDefs = null;
+    if (Array.isArray(argsTypeDefs)) {
+        typeDefs = argsTypeDefs;
+    }
+    else if (!isNil(argsTypeDefs)) {
+        typeDefs = Object.values(argsTypeDefs);
+    }
+    const inverseAliases = {};
+    const shadowedAliases = [];
+    const context = {};
+    if (version === 1.1) {
+        context['@version'] = version;
+    }
+    if (vocab != null) {
+        context['@vocab'] = vocab;
+    }
+    if (protect) {
+        context['@protected'] = true;
+    }
+    if (idTerm != null) {
+        context[idTerm] = '@id';
+    }
+    if (Array.isArray(typeDefs)) {
+        for (const typeDef of typeDefs) {
+            if (typeDef.term.startsWith('@')) {
+                throw new Error(`Terms cannot start with @. Recieved ${typeDef.term}`);
+            }
+            if (typeof aliases !== 'undefined' && Object.hasOwn(aliases, typeDef.term)) {
+                shadowedAliases.push(typeDef.term);
+            }
+        }
+    }
+    if (typeof aliases !== 'undefined') {
+        for (const [alias, iri] of Object.entries(aliases)) {
+            if (iri === vocab) {
+                continue;
+            }
+            if (!shadowedAliases.includes(alias)) {
+                context[alias] = iri;
+                inverseAliases[iri] = alias;
+            }
+        }
+    }
+    if (Array.isArray(typeDefs)) {
+        for (const typeDef of typeDefs) {
+            if (idTerm === typeDef.term) {
+                continue;
+            }
+            let type = typeDef.type;
+            const matchesVocab = typeDef.type.startsWith(vocab);
+            if (vocab != null && matchesVocab) {
+                type = typeDef.type.replace(vocab, '');
+            }
+            else if (typeof aliases !== 'undefined') {
+                for (const [alias, value] of Object.entries(aliases)) {
+                    if (typeDef.type.startsWith(value)) {
+                        type = typeDef.type.replace(value, `${alias}:`);
+                    }
+                }
+            }
+            if (!matchesVocab && isPopulatedObject(typeDef.contextDefinition)) {
+                context[typeDef.term] = {
+                    '@id': type,
+                    ...typeDef.contextDefinition,
+                };
+            }
+            else if (isPopulatedObject(typeDef.contextDefinition)) {
+                context[typeDef.term] = {
+                    '@id': type,
+                    ...typeDef.contextDefinition,
+                };
+            }
+            else if (!matchesVocab) {
+                context[typeDef.term] = type;
+            }
+        }
+    }
+    return context;
+}

package/dist/utils/getActionContext.d.ts

@@ -0,0 +1,7 @@
+import type { JSONLDContext } from "../jsonld.js";
+import type { ActionSpec } from '../actions/spec.js';
+export declare function getActionContext({ spec, vocab, aliases, }: {
+    vocab?: string;
+    aliases?: Record<string, string>;
+    spec: ActionSpec;
+}): JSONLDContext;

package/dist/utils/getActionContext.js

@@ -0,0 +1,48 @@
+import { makeTypeDef, makeTypeDefs } from "../makeTypeDefs.js";
+import { contextBuilder } from "./contextBuilder.js";
+const defaultTypeDefs = makeTypeDefs([
+    makeTypeDef({ schema: 'https://schema.org/', term: 'Entrypoint' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'target' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'httpMethod' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'urlTemplate' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'PropertyValueSpecification' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'maxValue' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'minValue' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'readonlyValue' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'stepValue' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'valueName' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'valueRequired' }),
+    makeTypeDef({ schema: 'https://schema.org/', term: 'multipleValues' }),
+]);
+export function getActionContext({ spec, vocab, aliases, }) {
+    const typeDefs = Object.values(defaultTypeDefs);
+    function searchAndAssignContextValues(term, propertySpec) {
+        if (propertySpec.typeDef != null) {
+            typeDefs.push(propertySpec.typeDef);
+            typeDefs.push(makeTypeDef({
+                term: `${term}-input`,
+                type: `${propertySpec.typeDef.type}-input`,
+            }));
+        }
+        else if (propertySpec.type === 'string') {
+            typeDefs.push(makeTypeDef({ term, type: propertySpec.type }));
+            typeDefs.push(makeTypeDef({
+                term: `${term}-input`,
+                type: `${propertySpec.type}-input`,
+            }));
+        }
+        if (propertySpec.properties != null) {
+            for (const [term, childPropertySpec] of Object.entries(propertySpec.properties)) {
+                searchAndAssignContextValues(term, childPropertySpec);
+            }
+        }
+    }
+    for (const [term, propertySpec] of Object.entries(spec)) {
+        searchAndAssignContextValues(term, propertySpec);
+    }
+    return contextBuilder({
+        vocab,
+        aliases,
+        typeDefs,
+    });
+}

package/dist/utils/getInternalName.d.ts

@@ -0,0 +1,6 @@
+export declare function getInternalName({ paramName, specValue, }: {
+    paramName: string;
+    specValue: {
+        internalTerm?: string;
+    };
+}): string;

package/dist/utils/getInternalName.js

@@ -0,0 +1,7 @@
+import { isPopulatedString } from "./isPopulatedString.js";
+export function getInternalName({ paramName, specValue, }) {
+    if (isPopulatedString(specValue.internalTerm)) {
+        return specValue.internalTerm;
+    }
+    return paramName;
+}

package/dist/utils/getParamLocation.d.ts

@@ -0,0 +1,2 @@
+export type ParamLocation = 'path' | 'search';
+export declare function getParamLocation(valueName: string, urlPattern: URLPattern): ParamLocation;

package/dist/utils/getParamLocation.js

@@ -0,0 +1,6 @@
+export function getParamLocation(valueName, urlPattern) {
+    if (urlPattern.pathname.includes(`:${valueName}`)) {
+        return 'path';
+    }
+    return 'search';
+}

package/dist/utils/getPropertyValueSpecifications.d.ts

@@ -0,0 +1,2 @@
+import type { ActionSpec, SpecValue } from "../actions/spec.js";
+export declare function getPropertyValueSpecifications(spec: ActionSpec<any>): Promise<SpecValue>;

package/dist/utils/getPropertyValueSpecifications.js

@@ -0,0 +1,49 @@
+import { isNil } from "./isNil.js";
+import { isObject } from "./isObject.js";
+// deno-lint-ignore no-explicit-any
+export async function getPropertyValueSpecifications(spec) {
+    async function splitSpecAndValue(propertySpec) {
+        let options = null;
+        const specValue = {};
+        const inputSpec = {
+            '@type': 'https://schema.org/PropertyValueSpecification',
+            defaultValue: propertySpec.defaultValue,
+            maxValue: propertySpec.maxValue,
+            minValue: propertySpec.minValue,
+            readonlyValue: propertySpec.readonlyValue,
+            stepValue: propertySpec.stepValue,
+            valueName: propertySpec.valueName,
+            valueRequired: propertySpec.valueRequired,
+            multipleValues: propertySpec.multipleValues,
+            valueMinLength: propertySpec.valueMinLength,
+            valueMaxLength: propertySpec.valueMaxLength,
+            valuePatern: propertySpec.valuePattern,
+        };
+        if (typeof propertySpec.options === 'function') {
+            options = await propertySpec.options();
+        }
+        else if (!isNil(propertySpec.options)) {
+            options = propertySpec.options;
+        }
+        if (!isObject(propertySpec.properties)) {
+            return [inputSpec, options];
+        }
+        for (const [term, childPropertySpec] of Object.entries(propertySpec.properties)) {
+            const [childInputSpec, childSpecValue] = await splitSpecAndValue(childPropertySpec);
+            specValue[`${term}-input`] = childInputSpec;
+            if (childSpecValue != null) {
+                specValue[term] = childSpecValue;
+            }
+        }
+        return [inputSpec, specValue];
+    }
+    const specValue = {};
+    for (const [term, propertySpec] of Object.entries(spec)) {
+        const [childInputSpec, childSpecValue] = await splitSpecAndValue(propertySpec);
+        specValue[`${term}-input`] = childInputSpec;
+        if (childSpecValue != null) {
+            specValue[term] = childSpecValue;
+        }
+    }
+    return specValue;
+}

package/dist/utils/getRequestBodyValues.d.ts

@@ -0,0 +1,11 @@
+import type { JSONValue } from "../jsonld.js";
+import type { ContextState, ActionSpec } from "../actions/spec.js";
+import type { ImplementedAction } from "../actions/types.js";
+export type BodyValue = Record<string, JSONValue>;
+export type RequestBodyResult = {
+    bodyValues: BodyValue;
+};
+export declare function getRequestBodyValues<State extends ContextState = ContextState, Spec extends ActionSpec<ContextState> = ActionSpec<ContextState>>({ req, action, }: {
+    req: Request;
+    action: ImplementedAction<State, Spec>;
+}): Promise<RequestBodyResult>;

package/dist/utils/getRequestBodyValues.js

@@ -0,0 +1,122 @@
+import { ProblemDetailsError } from "../errors.js";
+import jsonld from 'jsonld';
+export async function getRequestBodyValues({ req, action, }) {
+    let bodyValues = {};
+    const contentType = req.headers.get('content-type');
+    const mappedTypes = Object.entries(action.spec)
+        .reduce((acc, [term, propertySpec]) => {
+        return {
+            ...acc,
+            [propertySpec.typeDef.term]: {
+                term,
+                propertySpec,
+            },
+            [propertySpec.type || propertySpec.typeDef?.type]: {
+                term,
+                propertySpec,
+            },
+        };
+    }, {});
+    if (contentType?.startsWith('multipart/form-data')) {
+        // multipart should be sent using expanded types which get normalized
+        // into the compact terms for each type.
+        // otherwise json requests would need to also need to use
+        // expanded terms.
+        const formData = await req.formData();
+        for (const [name, part] of formData.entries()) {
+            if (typeof name !== 'string') {
+                throw new ProblemDetailsError(400, {
+                    title: 'Unnamed parameter in request multipart body',
+                });
+            }
+            let term;
+            let propertySpec;
+            if (typeof part !== 'string' && (part.type && !part.type.startsWith('text/plain'))) {
+                term = mappedTypes[name].term;
+                propertySpec = mappedTypes[name].propertySpec;
+                if (!term || !propertySpec) {
+                    continue;
+                }
+                if (propertySpec.dataType !== 'file') {
+                    throw new ProblemDetailsError(400, {
+                        title: `Unexpected content '${name}' in request multipart body`,
+                    });
+                }
+                //bodyValues[term] = part;
+                bodyValues[term] = null;
+                continue;
+            }
+            if (typeof part === 'string' || part.type === 'text/plain' || part.type == null) {
+                term = mappedTypes[name].term;
+                propertySpec = mappedTypes[name].propertySpec;
+            }
+            else if (part.name) {
+                term = mappedTypes[name].term;
+                propertySpec = mappedTypes[name].propertySpec;
+            }
+            else {
+                throw new ProblemDetailsError(400, {
+                    title: `Unexpected content '${name}' in request multipart body`,
+                });
+            }
+            if (!term || !propertySpec) {
+                continue;
+            }
+            const textValue = typeof part === 'string' ? part : await part.text();
+            if (!textValue) {
+                continue;
+            }
+            if (propertySpec.dataType === 'number' && /\d+(\.\d+)?/.test(textValue)) {
+                bodyValues[term] = Number(textValue);
+            }
+            else if (propertySpec.dataType === 'boolean') {
+                bodyValues[term] = textValue === 'true';
+            }
+            else {
+                bodyValues[term] = textValue;
+            }
+        }
+    }
+    else if (contentType?.startsWith('application/json')) {
+        try {
+            bodyValues = await req.json();
+        }
+        catch {
+            throw new ProblemDetailsError(400, {
+                title: 'Failed to parse JSON body',
+            });
+        }
+    }
+    else if (contentType?.startsWith('application/ld+json')) {
+        let source;
+        let expanded;
+        let compacted;
+        try {
+            source = await req.json();
+        }
+        catch {
+            throw new ProblemDetailsError(400, {
+                title: 'Failed to parse JSON body',
+            });
+        }
+        try {
+            expanded = await jsonld.expand(source);
+        }
+        catch {
+            throw new ProblemDetailsError(400, {
+                title: 'Failed to expand JSON-LD body',
+            });
+        }
+        try {
+            compacted = await jsonld.compact(expanded, action.context);
+        }
+        catch {
+            throw new ProblemDetailsError(400, {
+                title: 'Failed to compact JSON-LD body',
+            });
+        }
+        delete compacted['@context'];
+        bodyValues = compacted;
+    }
+    return { bodyValues };
+}

package/dist/utils/getRequestIRIValues.d.ts

@@ -0,0 +1,14 @@
+import type { ImplementedAction } from "../actions/types.js";
+import type { ActionSpec, ContextState, FileSingleSpec, FileMultiSpec, BooleanSingleSpec, BooleanMultiSpec, NumberSingleSpec, NumberMultiSpec, StringSingleSpec, StringMultiSpec, ParsedIRIValues } from "../actions/spec.js";
+export type IRIValue<Spec extends ActionSpec<ContextState> = ActionSpec<ContextState>> = {
+    [Term in keyof Spec]: (Spec[Term] extends FileSingleSpec | FileMultiSpec ? never : Spec[Term]['valueName'] extends string ? (Spec[Term] extends BooleanSingleSpec ? boolean : Spec[Term] extends BooleanMultiSpec ? boolean[] : Spec[Term] extends NumberSingleSpec ? number : Spec[Term] extends NumberMultiSpec ? number[] : Spec[Term] extends StringSingleSpec ? string : Spec[Term] extends StringMultiSpec ? string[] : never) : never);
+};
+export type RequestIRIResult<Spec extends ActionSpec<ContextState> = ActionSpec<ContextState>> = {
+    pathValues: ParsedIRIValues;
+    queryValues: ParsedIRIValues;
+    iriValues: IRIValue<Spec>;
+};
+export declare function getRequestIRIValues<State extends ContextState = ContextState, Spec extends ActionSpec<ContextState> = ActionSpec<ContextState>>({ iri, action, }: {
+    iri: string;
+    action: ImplementedAction<State, Spec>;
+}): RequestIRIResult<Spec>;