mailschema 0.2.2 → 0.3.1

package/dist/map.d.ts

@@ -1,8 +0,0 @@
-/** A fresh copy of the MAP 0.2 core schema, as the profile record binds it by SHA-256. */
-export declare function getMapSchema(): Record<string, unknown>;
-/** A fresh copy of the MAP 0.2 JSON-LD context. */
-export declare function getMapContext(): Record<string, unknown>;
-/** A fresh copy of the type contract format every MAP 0.2 contract follows. */
-export declare function getContractFormatSchema(): Record<string, unknown>;
-/** A fresh copy of the form fields block contracts pin. */
-export declare function getFormsSchema(): Record<string, unknown>;

package/dist/map.js

@@ -1,18 +0,0 @@
-import { readFileSync } from 'node:fs';
-const artifact = (name) => JSON.parse(readFileSync(new URL(`./${name}`, import.meta.url), 'utf8'));
-/** A fresh copy of the MAP 0.2 core schema, as the profile record binds it by SHA-256. */
-export function getMapSchema() {
-    return artifact('map-0.2.schema.json');
-}
-/** A fresh copy of the MAP 0.2 JSON-LD context. */
-export function getMapContext() {
-    return artifact('map-0.2.jsonld');
-}
-/** A fresh copy of the type contract format every MAP 0.2 contract follows. */
-export function getContractFormatSchema() {
-    return artifact('type-contract-0.2.schema.json');
-}
-/** A fresh copy of the form fields block contracts pin. */
-export function getFormsSchema() {
-    return artifact('forms-0.1.schema.json');
-}

package/dist/model.d.ts

@@ -1,95 +0,0 @@
-export declare const typeStages: readonly [{
-    readonly status: "Draft";
-    readonly singular: "draft";
-    readonly plural: "drafts";
-}, {
-    readonly status: "Proposal";
-    readonly singular: "proposal";
-    readonly plural: "proposals";
-}, {
-    readonly status: "Reuse assessment";
-    readonly singular: "reuse assessment";
-    readonly plural: "reuse assessments";
-}];
-export interface Party {
-    name: string;
-    url?: string;
-}
-export interface TypeDefinition {
-    slug: string;
-    name: string;
-    summary: string;
-    category: string;
-    status: (typeof typeStages)[number]['status'];
-    version: string | null;
-    profile: string;
-    overview: string;
-    target: string;
-    operations: {
-        id: string;
-        name: string;
-        description: string;
-    }[];
-    inputs: string;
-    results: string;
-    permissions: string;
-    humanRoute: string;
-    example: {
-        title: string;
-        steps: string[];
-        exception: string;
-    };
-    references: {
-        title: string;
-        href: string;
-        description: string;
-    }[];
-    openQuestions: string[];
-    maintainers: Party[];
-    definition?: {
-        label: string;
-        href: string;
-    };
-}
-export interface TypeRecord extends TypeDefinition {
-    origin: string;
-    contributors: Party[];
-    history: {
-        label: string;
-        description: string;
-        contributionId?: string;
-    }[];
-}
-interface Submission {
-    format: 'mailschema-contribution/1';
-    id: string;
-    contributor: Party;
-    source?: string;
-    summary: string;
-}
-export type Contribution = Submission & ({
-    kind: 'new-type';
-    record: TypeDefinition;
-} | {
-    kind: 'amendment';
-    baseDigest: string;
-    record: TypeDefinition;
-} | {
-    kind: 'implementation';
-    type: string;
-    typeVersion: string;
-    typeDigest: string;
-    profile: string;
-    product: Party;
-    operations: string[];
-    evidence: {
-        kind: 'declaration' | 'test-report';
-        url?: string;
-        reproduction?: string;
-        results?: string;
-    };
-});
-export type Implementation = Extract<Contribution, {
-    kind: 'implementation';
-}>;
-export {};

package/dist/model.js

@@ -1,5 +0,0 @@
-export const typeStages = [
-    { status: 'Draft', singular: 'draft', plural: 'drafts' },
-    { status: 'Proposal', singular: 'proposal', plural: 'proposals' },
-    { status: 'Reuse assessment', singular: 'reuse assessment', plural: 'reuse assessments' },
-];

package/dist/type-contract-0.2.schema.json

@@ -1,179 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://mailschema.org/schemas/type-contract-0.2.schema.json",
-  "title": "MailSchema type contract for MAP 0.2",
-  "description": "A versioned interaction contract: the details, inputs, results, authority, repeatability and consequences of each operation, with every schema it depends on pinned by digest.",
-  "type": "object",
-  "additionalProperties": false,
-  "properties": {
-    "kind": {
-      "const": "MapTypeContract"
-    },
-    "id": {
-      "type": "string",
-      "pattern": "^https://mailschema\\.org/types/[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
-      "maxLength": 2048
-    },
-    "version": {
-      "type": "string",
-      "pattern": "^[0-9]+\\.[0-9]+(?:\\.[0-9]+)?(?:-[a-zA-Z0-9.-]+)?$",
-      "maxLength": 80
-    },
-    "profile": {
-      "const": "https://mailschema.org/profiles/map/0.2"
-    },
-    "target": {
-      "$ref": "#/$defs/prose"
-    },
-    "dependencies": {
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 20,
-      "items": {
-        "$ref": "#/$defs/schemaReference"
-      }
-    },
-    "detailsSchema": {
-      "type": "object"
-    },
-    "requestSchema": {
-      "$ref": "#/$defs/schemaReference"
-    },
-    "operations": {
-      "type": "array",
-      "minItems": 1,
-      "maxItems": 100,
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "id": {
-            "$ref": "#/$defs/token"
-          },
-          "effect": {
-            "$ref": "#/$defs/prose"
-          },
-          "authority": {
-            "type": "array",
-            "items": {
-              "enum": ["credential", "possession"]
-            },
-            "minItems": 1,
-            "maxItems": 2,
-            "uniqueItems": true
-          },
-          "consequences": {
-            "type": "array",
-            "items": {
-              "enum": [
-                "refusal",
-                "protection",
-                "record",
-                "disclosure",
-                "commitment",
-                "authorization",
-                "assertion"
-              ]
-            },
-            "minItems": 1,
-            "maxItems": 7,
-            "uniqueItems": true
-          },
-          "repeatable": {
-            "type": "boolean"
-          },
-          "fieldBindings": {
-            "type": "array",
-            "minItems": 1,
-            "maxItems": 10,
-            "items": {
-              "type": "object",
-              "additionalProperties": false,
-              "properties": {
-                "input": {
-                  "$ref": "#/$defs/pointer"
-                },
-                "fields": {
-                  "$ref": "#/$defs/pointer"
-                }
-              },
-              "required": ["input", "fields"]
-            }
-          },
-          "results": {
-            "type": "array",
-            "minItems": 1,
-            "maxItems": 5,
-            "items": {
-              "type": "object",
-              "additionalProperties": false,
-              "properties": {
-                "state": {
-                  "enum": ["accepted", "completed", "failed", "pending", "approval-required"]
-                },
-                "reasons": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/$defs/token"
-                  },
-                  "minItems": 1,
-                  "maxItems": 20,
-                  "uniqueItems": true
-                },
-                "outputSchema": {
-                  "type": "object"
-                }
-              },
-              "required": ["state", "outputSchema"]
-            }
-          }
-        },
-        "required": ["id", "effect", "authority", "consequences", "results"]
-      }
-    }
-  },
-  "required": [
-    "kind",
-    "id",
-    "version",
-    "profile",
-    "target",
-    "dependencies",
-    "requestSchema",
-    "operations"
-  ],
-  "$defs": {
-    "prose": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 12000,
-      "pattern": "[^\\t\\n\\u000b\\f\\r \\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff]"
-    },
-    "token": {
-      "type": "string",
-      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
-      "maxLength": 100
-    },
-    "pointer": {
-      "type": "string",
-      "pattern": "^(?:/(?:[^~/]|~[01])*)+$",
-      "maxLength": 1000
-    },
-    "schemaReference": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "url": {
-          "type": "string",
-          "pattern": "^https://mailschema\\.org/schemas/[a-z0-9.-]+\\.json$",
-          "maxLength": 2048
-        },
-        "canonicalDigest": {
-          "type": "string",
-          "pattern": "^sha-256:[a-f0-9]{64}$"
-        }
-      },
-      "required": ["url", "canonicalDigest"]
-    }
-  }
-}

package/dist/validation.d.ts

@@ -1,15 +0,0 @@
-import type { Contribution, TypeRecord } from './model.ts';
-export declare function contributionErrors(value: unknown): string[];
-export declare function assertContribution(value: unknown): asserts value is Contribution;
-export declare function assertTypeRecord(value: unknown): asserts value is TypeRecord;
-export interface CatalogView {
-    types: {
-        record: TypeRecord;
-        digest: string;
-    }[];
-    snapshots: {
-        record: TypeRecord;
-        digest: string;
-    }[];
-}
-export declare function referenceErrors(input: Contribution, catalog: CatalogView): string[];

package/dist/validation.js

@@ -1,64 +0,0 @@
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
-import schema from './contribution.schema.json' with { type: 'json' };
-const ajv = new Ajv2020({ allErrors: true, strict: true, strictRequired: false });
-addFormats(ajv);
-const contribution = ajv.compile(schema);
-const variants = new Map(schema.oneOf.map((variant) => [
-    variant.properties.kind.const,
-    ajv.compile({ $schema: schema.$schema, $defs: schema.$defs, ...variant }),
-]));
-const record = ajv.compile({
-    $schema: schema.$schema,
-    $defs: schema.$defs,
-    $ref: '#/$defs/record',
-});
-export function contributionErrors(value) {
-    const kind = value && typeof value === 'object' && 'kind' in value ? value.kind : undefined;
-    const validate = typeof kind === 'string' ? variants.get(kind) || contribution : contribution;
-    if (validate(value))
-        return [];
-    return (validate.errors || []).map((error) => `${error.instancePath || '/'} ${error.message}${error.keyword === 'required' ? `: ${error.params.missingProperty}` : ''}`);
-}
-export function assertContribution(value) {
-    const errors = contributionErrors(value);
-    if (errors.length)
-        throw new Error(`Invalid contribution:\n${errors.join('\n')}`);
-}
-export function assertTypeRecord(value) {
-    if (!record(value))
-        throw new Error(`Invalid type record: ${ajv.errorsText(record.errors, { separator: '\n' })}`);
-}
-export function referenceErrors(input, catalog) {
-    const errors = [];
-    if (input.kind === 'implementation') {
-        const target = catalog.snapshots.find((item) => item.digest === input.typeDigest)?.record;
-        if (!target || target.slug !== input.type || target.version !== input.typeVersion)
-            return [
-                'Unknown type version or record digest. Download the current record from the Registry.',
-            ];
-        if (target.profile !== input.profile)
-            errors.push('Execution profile does not match the targeted record.');
-        const operations = new Set(target.operations.map((operation) => operation.id));
-        if (new Set(input.operations).size !== input.operations.length ||
-            input.operations.some((operation) => !operations.has(operation)))
-            errors.push('Unknown or duplicate operation in the implementation declaration.');
-    }
-    else {
-        const existing = catalog.types.find((item) => item.record.slug === input.record.slug);
-        if (input.kind === 'new-type' && existing)
-            errors.push('This type already exists. Submit an amendment instead.');
-        if (input.kind === 'amendment' && (!existing || existing.digest !== input.baseDigest))
-            errors.push('Stale or unknown amendment base. Download the current record and reconcile your changes.');
-        if (catalog.types.some((item) => item.record.slug !== input.record.slug &&
-            item.record.name.toLocaleLowerCase() === input.record.name.toLocaleLowerCase()))
-            errors.push('Another type already uses this name.');
-        const operationIds = input.record.operations.map((operation) => operation.id);
-        const operationNames = input.record.operations.map((operation) => operation.name.toLocaleLowerCase());
-        if (new Set(operationIds).size !== operationIds.length)
-            errors.push('Operation identifiers must be unique within a type.');
-        if (new Set(operationNames).size !== operationNames.length)
-            errors.push('Operation names must be unique within a type.');
-    }
-    return errors;
-}