@occultist/occultist 0.0.1

package/dist/validators.js

@@ -0,0 +1,134 @@
+import { isObject } from './utils/isObject.js';
+import { preferredMediaTypes } from './utils/preferredMediaTypes.js';
+// deno-lint-ignore no-explicit-any
+export function isFileData(value) {
+    if (typeof value === 'string' && value.startsWith('data:')) {
+        return true;
+    }
+    else if (value instanceof File) {
+        return true;
+    }
+    return false;
+}
+export function isObjectArraySpec(spec) {
+    return isObject(spec.properties) && Boolean(spec.multipleValues);
+}
+export function isObjectSpec(spec) {
+    return isObject(spec.properties) && !spec.multipleValues;
+}
+export function isArraySpec(spec) {
+    return !isObject(spec.properties) && Boolean(spec.multipleValues);
+}
+export function failsRequiredRequirement(value, specValue) {
+    return specValue.valueRequired && (typeof value === 'undefined' || value === null);
+}
+export function failsTypeRequirement(value, specValue) {
+    const dataType = specValue.dataType;
+    if (dataType == null) {
+        return false;
+    }
+    else if (specValue.dataType === 'file' && isFileData(value)) {
+        return false;
+    }
+    else if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index++) {
+            const item = value[index];
+            // deno-lint-ignore valid-typeof
+            if (typeof item !== dataType) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // deno-lint-ignore valid-typeof
+    return typeof value !== specValue.dataType;
+}
+export function failsContentTypeRequirement(value, specValue) {
+    if (specValue.type !== 'file' ||
+        specValue.contentType == null ||
+        !isFileData(value)) {
+        return false;
+    }
+    let contentType;
+    if (typeof value === 'string') {
+        contentType = value.replace(/^data\:/, '').split(';')[0];
+    }
+    else {
+        contentType = value.type;
+    }
+    if (contentType == null) {
+        return true;
+    }
+    else if (typeof specValue.contentType === 'string') {
+        return !preferredMediaTypes(contentType, [specValue.contentType]);
+    }
+    return !preferredMediaTypes(contentType, specValue.contentType);
+}
+export function failsMinValue(value, specValue) {
+    if (!specValue.valueRequired && value == null) {
+        return false;
+    }
+    if (typeof specValue.minValue !== 'number') {
+        return false;
+    }
+    else if (typeof value !== 'number') {
+        return true;
+    }
+    return value < specValue.minValue;
+}
+export function failsMaxValue(value, specValue) {
+    if (!specValue.valueRequired && value == null) {
+        return false;
+    }
+    if (typeof specValue.maxValue !== 'number') {
+        return false;
+    }
+    else if (typeof value !== 'number') {
+        return true;
+    }
+    return value > specValue.maxValue;
+}
+export function failsStepValue(value, specValue) {
+    if (typeof specValue.stepValue !== 'number') {
+        return false;
+    }
+    else if (typeof value !== 'number') {
+        return true;
+    }
+    return value % specValue.stepValue !== 0;
+}
+export function failsPatternValue(value, specValue) {
+    if (typeof specValue.valuePattern !== 'string') {
+        return false;
+    }
+    else if (typeof value !== 'string') {
+        return true;
+    }
+    const regexp = new RegExp(specValue.valuePattern);
+    return !regexp.test(value);
+}
+export function failValueMinLength(value, specValue) {
+    if (typeof specValue.valueMinLength !== 'number') {
+        return false;
+    }
+    if (typeof value === 'string' || Array.isArray(value)) {
+        return value.length < specValue.valueMinLength;
+    }
+    return true;
+}
+export function failValueMaxLength(value, specValue) {
+    if (typeof specValue.valueMaxLength !== 'number') {
+        return false;
+    }
+    if (typeof value === 'string' || Array.isArray(value)) {
+        return value.length > specValue.valueMaxLength;
+    }
+    return true;
+}
+export function failsValidator(value, specValue) {
+    if (typeof specValue.validator !== 'function') {
+        return false;
+    }
+    const validator = specValue.validator;
+    return !validator(value);
+}

package/lib/accept.test.ts

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import { Accept, ContentTypeCache } from "./accept.js";
+
+const cache = new ContentTypeCache([
+  'text/html',
+  'application/ld+json',
+  'application/json',
+]);
+
+test('Matches with no accepts header', () => {
+  const accept = Accept.from(new Request('https://example.com'));
+
+  assert(accept.negotiate(cache) === 'text/html');
+});
+
+test('Matches with specific accepts header', () => {
+  const accept = Accept.from(new Request('https://example.com', {
+    headers: {
+      accept: 'application/ld+json',
+    },
+  }));
+  
+  assert(accept.negotiate(cache) === 'application/ld+json');
+});
+
+test('Matches with glob header', () => {
+  const accept = Accept.from(new Request('https://example.com', {
+    headers: {
+      accept: '*/*',
+    },
+  }));
+  
+  assert(accept.negotiate(cache) === 'text/html');
+});
+
+test('Matches with glob subtype header', () => {
+  const accept = Accept.from(new Request('https://example.com', {
+    headers: {
+      accept: 'application/*',
+    },
+  }));
+  
+  assert(accept.negotiate(cache) === 'application/ld+json');
+});
+
+test('Matches q prioritizing in header', () => {
+  const accept = Accept.from(new Request('https://example.com', {
+    headers: {
+      accept: 'text/html; q=0.5, application/json; q=1, text/cvs; q=.7',
+    },
+  }));
+
+  assert(accept.negotiate(cache) === 'application/json');
+});

package/lib/accept.ts

@@ -0,0 +1,147 @@
+
+
+/**
+ * Creates a content type cache usually from the set of content type
+ * options supported by an action or action set.
+ */
+export class ContentTypeCache {
+  default: string;
+  set: Set<string>;
+  map: Map<string, string> = new Map();
+  contentTypes: string[];
+
+  constructor(contentTypes: string[]) {
+    this.default = contentTypes[0];
+    this.contentTypes = contentTypes;
+    this.set = new Set(contentTypes);
+
+    this.set.add('*/*');
+    this.map.set('*/*', contentTypes[0]);
+
+    for (let index = 0; index < contentTypes.length; index++) {
+      const contentType = contentTypes[index];
+      const type = contentType.replace(/[^\/]*$/, '*');
+      
+      this.map.set(contentType, contentType);
+
+      if (!this.map.has(type)) {
+        this.set.add(type);
+        this.map.set(type, contentType);
+      }
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return `[ContentTypeCache ${this.contentTypes.join(' ')}]`;
+  }
+}
+
+/**
+ * This accept object is created from a request before any content negotiation
+ * begins allowing all subsequent checks to re-use the same caches header values.
+ *
+ * @todo Implement support for all accept headers.
+ *
+ * @param accept - The value of the request's accept header.
+ * @param acceptLanguage - The value of the request's accept-language header.
+ * @param acceptEncoding - The value of the request's accept-encoding header.
+ */
+export class Accept {
+  acceptRe = /(?<ct>[^,;\s]+)(;\s?q=(?<q>(\d(\.\d+)|(.\d))))?/g;
+  accept: string[] = [];
+  acceptCache: Set<string> = new Set();
+  //#acceptLanguage: string[] = [];
+  //#acceptLanguageCache: Set<string> = new Set();
+  //#acceptEncoding: string[] = [];
+  //#acceptEncodingCache: Set<string> = new Set();
+
+  constructor(
+    accept: string | null,
+    _acceptLanguage: string | null,
+    _acceptEncoding: string | null,
+  ) {
+    [this.accept, this.acceptCache] = this.#process(accept);
+    //[this.#acceptLanguage, this.#acceptLanguageCache] = this.#process(acceptLanguage);
+    //[this.#acceptEncoding, this.#acceptEncodingCache] = this.#process(acceptEncoding);
+  }
+
+  /**
+   * Creates an accept instance from a request or response instance
+   */
+  static from(req: Request): Accept {
+    const accept = req.headers.get('Accept');
+    const acceptLanguage = req.headers.get('Accept-Language');
+    const acceptEncoding = req.headers.get('Accept-Encoding');
+
+    console.log('ACCEPT', accept);
+    
+    return new Accept(
+      accept,
+      acceptLanguage,
+      acceptEncoding,
+    );
+  }
+
+  debug() {
+    return this.accept.join(' ');
+  }
+
+  /**
+   * Negotiates against the cached set of content type options.
+   *
+   * @param contentType Content type cache built for an action.
+   */
+  negotiate(contentType: ContentTypeCache): null | string {
+    if (this.accept.length === 0) {
+      return contentType.default;
+    }
+
+    // TODO: check might be over-optimizing.
+    const intersection = this.acceptCache.intersection(contentType.set);
+    
+    if (intersection.size === 0) {
+      return null;
+    }
+    
+    for (let index = 0; index < this.accept.length; index++) {
+      const match = contentType.map.get(this.accept[index]);
+
+      if (match != null) {
+        return match;
+      }
+    }
+
+    return null;
+  }
+
+  #process(header: string | null): [string[], Set<string>] {
+    if (header == null) {
+      return [[], new Set('*/*')];
+    }
+
+    let match: RegExpExecArray | null;
+
+    const items: Array<{ ct: string, q: number }> = [];
+    const cache = new Set<string>();
+
+    while ((match = this.acceptRe.exec(header))) {
+      const ct = match.groups?.ct as string;
+      const q = Number(match.groups?.q ?? 1);
+
+      cache.add(ct);
+      items.push({ ct, q });
+    }
+    
+    items.sort((a, b) => b.q - a.q);
+    
+    return [
+      items.map(({ ct }) => ct),
+      cache,
+    ];
+  }
+
+  get [Symbol.toStringTag]() {
+    return `[Accept ${this.accept.join(' ')}]`
+  }
+}
+

package/lib/action.test.ts

@@ -0,0 +1,2 @@
+
+

package/lib/actions/actionSets.ts

@@ -0,0 +1,88 @@
+import { ContentTypeCache, type Accept } from "../accept.js";
+import { makeURLPattern } from "../utils/makeURLPattern.js";
+import type { ActionMeta } from "./meta.js";
+import type { ImplementedAction } from "./types.js";
+
+
+export type UnsupportedContentTypeMatch = {
+  type: 'unsupported-content-type';
+  contentTypes: string[];
+};
+
+export type ActionAcceptMatch = {
+  type: 'match';
+  action: ImplementedAction;
+  contentType?: string;
+  language?: string;
+  encoding?: string;
+};
+
+export type ActionMatchResult =
+  | UnsupportedContentTypeMatch
+  | ActionAcceptMatch
+;
+
+/**
+ * A set of actions grouped by having equal methods and equivilent paths.
+ */
+export class ActionSet {
+  #rootIRI: string;
+  #method: string;
+  #urlPattern: URLPattern;
+  #contentTypeActionMap: Map<string, ImplementedAction>;
+  #ctc: ContentTypeCache;
+
+  constructor(
+    rootIRI: string,
+    method: string,
+    path: string,
+    meta: ActionMeta[],
+  ) {
+    this.#rootIRI = rootIRI;
+    this.#method = method;
+
+    this.#urlPattern = makeURLPattern(path, rootIRI);
+
+    [this.#contentTypeActionMap, this.#ctc] = this.#process(meta);
+  }
+
+  matches(method: string, path: string, accept: Accept): null | ActionMatchResult {
+    if (method !== this.#method) {
+      return null;
+    } else if (!this.#urlPattern.test(path, this.#rootIRI)) {
+      return null;
+    }
+
+    const contentType = accept.negotiate(this.#ctc);
+    const action = this.#contentTypeActionMap.get(contentType as string);
+
+    if (contentType != null && action != null) {
+      return {
+        type: 'match',
+        action,
+        contentType,
+      };
+    }
+
+    return null;
+  }
+
+  #process(meta: ActionMeta[]): [Map<string, ImplementedAction>, ContentTypeCache] {
+    const contentTypes: string[] = [];
+    const contentTypeActionMap: Map<string, ImplementedAction> = new Map();
+
+    for (let i = 0; i < meta.length; i++) {
+      const action = meta[i].action as ImplementedAction;
+
+      for (let j = 0; j < action.contentTypes.length; j++) {
+        const contentType = action.contentTypes[j];
+
+        contentTypes.push(contentType);
+        contentTypeActionMap.set(contentType, action);
+      }
+    }
+
+    return [contentTypeActionMap, new ContentTypeCache(contentTypes)];
+  }
+}
+