@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/ValidationReport-Dx3WxY0h.d.mts

@@ -0,0 +1,192 @@
+import { d as NamedNode, l as Literal, o as Graph, s as GroundTerm, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import "./index-Cms2TYfC.mjs";
+import { i as Path } from "./Path-DRB8e-Zn.mjs";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Result from "effect/Result";
+declare namespace ValidationReport_d_exports {
+  export { ReportRdf, ReportSyntaxError, ToDatasetOptions, ValidationReport, ValidationReportSchema, ValidationResult, format, formatResult, fromDataset, hasNoViolations, isValidationReport, make, makeResult, toDataset, toRdf, violations, withSeverity };
+}
+/**
+ * A single validation result (`sh:ValidationResult`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ValidationResult {
+  readonly _tag: 'ValidationResult';
+  /** `sh:focusNode`: the focus node that was validated. */
+  readonly focusNode: GroundTerm;
+  /** `sh:resultPath`: the path of the property shape, when relevant. */
+  readonly resultPath: Option.Option<Path>;
+  /** `sh:value`: the value node that caused the result, when relevant. */
+  readonly value: Option.Option<GroundTerm>;
+  /** `sh:sourceShape`: the shape the constraint belongs to. */
+  readonly sourceShape: NamedNode | BlankNode;
+  /** `sh:sourceConstraintComponent`. */
+  readonly sourceConstraintComponent: NamedNode | BlankNode;
+  /** `sh:sourceConstraint` (for SPARQL-based constraints). */
+  readonly sourceConstraint: Option.Option<NamedNode | BlankNode>;
+  /** `sh:resultSeverity`. */
+  readonly severity: NamedNode;
+  /** `sh:resultMessage` values. */
+  readonly messages: ReadonlyArray<Literal>;
+  /** `sh:detail`: nested results explaining this result. */
+  readonly details: ReadonlyArray<ValidationResult>;
+}
+/**
+ * A validation report (`sh:ValidationReport`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ValidationReport {
+  readonly _tag: 'ValidationReport';
+  /** `sh:conforms`: true when there are no validation results. */
+  readonly conforms: boolean;
+  /** `sh:result` values. */
+  readonly results: ReadonlyArray<ValidationResult>;
+}
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const makeResult: (fields: {
+  readonly focusNode: GroundTerm;
+  readonly sourceShape: NamedNode | BlankNode;
+  readonly sourceConstraintComponent: NamedNode | BlankNode;
+  readonly severity?: NamedNode | undefined;
+  readonly resultPath?: Option.Option<Path> | undefined;
+  readonly value?: Option.Option<GroundTerm> | undefined;
+  readonly sourceConstraint?: Option.Option<NamedNode | BlankNode> | undefined;
+  readonly messages?: ReadonlyArray<Literal> | undefined;
+  readonly details?: ReadonlyArray<ValidationResult> | undefined;
+}) => ValidationResult;
+/**
+ * Builds a report from results; `conforms` is true iff there are none.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: (results: ReadonlyArray<ValidationResult>) => ValidationReport;
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+declare const isValidationReport: (u: unknown) => u is ValidationReport;
+/**
+ * Schema of a validation report; its JSON codec is `{ results }`, mirroring
+ * the result model with terms as `TermJson` terms and `Option`s in Effect's
+ * JSON form (`conforms` is recomputed from the results on decode).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const ValidationReportSchema: Schema.declare<ValidationReport>;
+/**
+ * The type `ValidationReportSchema` decodes to: a `ValidationReport`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+type ValidationReportSchema = typeof ValidationReportSchema.Type;
+/**
+ * The results with a given severity.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const withSeverity: (self: ValidationReport, severity: NamedNode) => ReadonlyArray<ValidationResult>;
+/**
+ * The `sh:Violation` results.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const violations: (self: ValidationReport) => ReadonlyArray<ValidationResult>;
+/**
+ * Whether the report has no results of severity `sh:Violation` (it may still
+ * contain warnings and informational results).
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const hasNoViolations: (self: ValidationReport) => boolean;
+/**
+ * A human-readable, multi-line summary of a report.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const format: (self: ValidationReport) => string;
+/**
+ * Formats one validation result on one line (without its details):
+ * severity, constraint component, focus node, path, value, shape and the
+ * first message.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatResult: (r: ValidationResult) => string;
+/**
+ * Options for `toDataset`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ToDatasetOptions {
+  /** The graph to write the report into (default graph by default). */
+  readonly graph?: Graph | undefined;
+  /** Include `sh:detail` results (default `true`). */
+  readonly details?: boolean | undefined;
+  /** Include `sh:resultMessage` values (default `true`). */
+  readonly messages?: boolean | undefined;
+}
+/**
+ * A validation report encoded as RDF: the report's node and the graph
+ * describing it.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+interface ReportRdf {
+  readonly node: BlankNode;
+  readonly dataset: Dataset;
+}
+/**
+ * Converts a report to the standard RDF validation report graph, using fresh
+ * blank nodes for the report, its results and any non-IRI result paths.
+ * Returns the report node together with the dataset.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const toRdf: (self: ValidationReport, options?: ToDatasetOptions) => ReportRdf;
+/**
+ * Converts a report to the standard RDF validation report graph.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const toDataset: (self: ValidationReport, options?: ToDatasetOptions) => Dataset;
+declare const ReportSyntaxError_base: Schema.Class<ReportSyntaxError, Schema.TaggedStruct<"ReportSyntaxError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Why an RDF validation report could not be read.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class ReportSyntaxError extends ReportSyntaxError_base {}
+/**
+ * Reads a validation report from RDF. The report node defaults to the (only)
+ * instance of `sh:ValidationReport` in the dataset.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const fromDataset: (dataset: Dataset, reportNode?: NamedNode | BlankNode) => Result.Result<ValidationReport, ReportSyntaxError>;
+export { violations as _, ValidationReportSchema as a, format as c, hasNoViolations as d, isValidationReport as f, toRdf as g, toDataset as h, ValidationReport as i, formatResult as l, makeResult as m, ReportSyntaxError as n, ValidationReport_d_exports as o, make as p, ToDatasetOptions as r, ValidationResult as s, ReportRdf as t, fromDataset as u, withSeverity as v };
+//# sourceMappingURL=ValidationReport-Dx3WxY0h.d.mts.map

package/dist/Validator-227ff9Rn.d.mts

@@ -0,0 +1,179 @@
+import { s as GroundTerm } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { a as ShExStructureError, n as ShExImportError, o as ShExValidationError } from "./ShExError-BeYFD9rv.mjs";
+import { B as ShapeDecl, M as Schema$1, P as SemAct, U as ShapeExprOrRef } from "./ShExJ-C1u_wgyD.mjs";
+import { c as ShapeSelector, o as QueryShapeMap, t as Association } from "./ShapeMap-C422pxKl.mjs";
+import { t as SchemaIndex } from "./Structure-n4CmDiab.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+declare namespace Validator_d_exports {
+  export { Loader, Options, SchemaLoader, ShapeResult, ValidationReport, Validator, formatResult, loaderFromRecord, loaderLayer, make, resolveImports, schema, validate, validateNode };
+}
+/**
+ * Loads imported schemas by IRI.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Loader {
+  readonly load: (iri: string) => Effect.Effect<Schema$1, ShExImportError>;
+}
+/**
+ * The service used to resolve `IMPORT`s. The default loader fails for every
+ * import.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+declare const SchemaLoader: Context.Reference<Loader>;
+/**
+ * A layer providing a `SchemaLoader`.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+declare const loaderLayer: (loader: Loader) => Layer.Layer<never>;
+/**
+ * A loader serving schemas from a map of IRIs (useful for tests and bundled
+ * schemas).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const loaderFromRecord: (schemas: Readonly<Record<string, Schema$1>>) => Loader;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Options {
+  /**
+   * Definitions for shapes declared `EXTERNAL`, given as a schema whose
+   * declarations share the external labels.
+   */
+  readonly externalShapes?: Schema$1 | undefined;
+  /**
+   * Code for semantic actions written without code (`%<name>%`), matched by
+   * action name.
+   */
+  readonly externalSemActs?: ReadonlyArray<SemAct> | undefined;
+  /** The IRI of the schema itself, so that circular imports of it are ignored. */
+  readonly schemaIri?: string | undefined;
+}
+/**
+ * The validation result of one node/shape association.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ShapeResult {
+  readonly node: GroundTerm;
+  readonly shape: ShapeSelector;
+  readonly status: 'conformant' | 'nonconformant';
+  /** Why the node does not conform. */
+  readonly reason?: string;
+}
+/**
+ * A validation report: one result per association of the (fixed) shape map.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ValidationReport {
+  readonly results: ReadonlyArray<ShapeResult>;
+  /** Whether every association conforms. */
+  readonly conformant: boolean;
+}
+/**
+ * A validator for one (import-resolved, structurally checked) schema.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Validator {
+  /** The schema with the declarations of its imports merged in. */
+  readonly schema: Schema$1;
+  readonly index: SchemaIndex;
+  /** Validates a fixed or query shape map against a dataset. */
+  readonly validate: (dataset: Dataset, shapeMap: QueryShapeMap) => Effect.Effect<ValidationReport, ShExValidationError>;
+}
+/**
+ * Loads the imports of a schema (transitively, each IRI once) and merges
+ * their declarations into it. The importing schema's `start` and `startActs`
+ * are kept.
+ *
+ * @since 0.1.0
+ * @category imports
+ */
+declare const resolveImports: (schema: Schema$1, schemaIri?: string | undefined) => Effect.Effect<Schema$1 | {
+  type: "Schema";
+  '@context'?: string;
+  startActs?: ReadonlyArray<SemAct>;
+  start?: ShapeExprOrRef;
+  shapes?: ReadonlyArray<ShapeDecl>;
+}, ShExImportError, never>;
+/**
+ * Prepares a validator: loads imports through `SchemaLoader`, checks the
+ * structural requirements and indexes the schema. Semantic actions are
+ * dispatched to the `SemAct.SemActHandler` in scope when the validator is
+ * made.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const make: (schema: Schema$1, options?: Options | undefined) => Effect.Effect<{
+  schema: Schema$1 | {
+    type: "Schema";
+    '@context'?: string;
+    startActs?: ReadonlyArray<SemAct>;
+    start?: ShapeExprOrRef;
+    shapes?: ReadonlyArray<ShapeDecl>;
+  };
+  index: SchemaIndex;
+  validate: (dataset: Dataset, shapeMap: QueryShapeMap) => Effect.Effect<ValidationReport, ShExValidationError>;
+}, ShExStructureError | ShExImportError, never>;
+/**
+ * Validates a shape map against a dataset with a schema.
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const validate: (dataset: Dataset, schema: Schema$1, shapeMap: QueryShapeMap, options?: Options) => Effect.Effect<ValidationReport, ShExValidationError | ShExImportError | ShExStructureError>;
+/**
+ * Validates a single node against a shape label (or `START`).
+ *
+ * @since 0.1.0
+ * @category validation
+ */
+declare const validateNode: (dataset: Dataset, schema: Schema$1, node: GroundTerm, shape: ShapeSelector, options?: Options) => Effect.Effect<ShapeResult, ShExValidationError | ShExImportError | ShExStructureError>;
+/**
+ * Formats a shape result on one line: `<node>@<shape>` and, when it does
+ * not conform, why.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatResult: (result: ShapeResult) => string;
+/**
+ * A `Schema` that accepts a `Dataset` only if every association of the
+ * shape map (or the single `{ node, shape }`) conforms, so ShEx validation
+ * fits into `Schema.decode` pipelines. It takes a prepared `Validator`
+ * (`make`), so imports are resolved before the schema is built and decoding
+ * needs no services.
+ *
+ * Decoding fails with a `SchemaIssue.Composite` holding one `InvalidValue`
+ * issue per nonconformant association: its `message` annotation is the
+ * formatted result (`formatResult`) and its `result` annotation the
+ * `ShapeResult`. A shape map naming an undeclared shape fails with one
+ * `InvalidValue`. Encoding is the identity.
+ *
+ * Compose it with a syntax codec to parse and validate in one decode:
+ * `Turtle.codec.schema.pipe(Schema.decodeTo(Validator.schema(validator, map)))`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const schema: (validator: Validator, shapeMap: QueryShapeMap | Association) => Schema.decodeTo<Schema.declare<Dataset>, Schema.declare<Dataset>>;
+export { ValidationReport as a, formatResult as c, make as d, resolveImports as f, validateNode as h, ShapeResult as i, loaderFromRecord as l, validate as m, Options as n, Validator as o, schema as p, SchemaLoader as r, Validator_d_exports as s, Loader as t, loaderLayer as u };
+//# sourceMappingURL=Validator-227ff9Rn.d.mts.map