@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Resource-sIEeNh15.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource-sIEeNh15.mjs","names":["Term.isLiteral","LanguageTag.normalize","Dataset.subjectsOf","Dataset.objectsOf","Term.Order","Term.isSubject","Dataset.list","Dataset.match","Term.isTerm","Term.Quad","Term.blankNode","Term.isObject","Term.defaultGraph","Term.NamedNodeSchema","Term.BlankNodeSchema","Term.TripleSchema","Dataset.DatasetSchema","Dataset.fromIterable"],"sources":["../src/Resource.ts"],"sourcesContent":["/**\n * Typed records over the resources of a `Dataset`: annotate a `Schema.Struct`\n * with the predicate behind each field, then decode a subject's properties\n * into the struct's type and encode a value back to quads.\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: Resource.property(foaf('name'), TermCodec.string),\n *   nick: Schema.optional(Resource.property(foaf('nick'), TermCodec.string)),\n *   knows: Resource.property(foaf('knows'), Schema.Array(TermCodec.namedNode)),\n * }).pipe(Resource.describe({ type: foaf('Person') }))\n *\n * Resource.decode(Person)(dataset, alice) // Effect<{ name: string; nick?: string; … }, SchemaError>\n * Resource.encode(Person)(alice, value) // Effect<ReadonlyArray<Quad>, SchemaError>\n * ```\n *\n * A field's cardinality comes from its schema: a plain codec reads exactly\n * one object, `Schema.optional` / `Schema.optionalKey` at most one,\n * `Schema.Array` any number (in `Term.Order`) and `list` an RDF collection.\n * A field whose codec is a struct is a nested resource, decoded from the\n * object's own properties. Each value decodes through its field's codec (see\n * `TermCodec`), and failures are ordinary schema issues at the field's path.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Option from 'effect/Option';\nimport * as Predicate from 'effect/Predicate';\nimport * as Record from 'effect/Record';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport * as SchemaIssue from 'effect/SchemaIssue';\nimport * as SchemaParser from 'effect/SchemaParser';\nimport * as SchemaTransformation from 'effect/SchemaTransformation';\nimport * as Dataset from './Dataset.ts';\nimport * as LanguageTag from './LanguageTag.ts';\nimport * as Term from './Term.ts';\nimport { rdf } from './Vocab.ts';\n\n// -----------------------------------------------------------------------------\n// Annotations\n// -----------------------------------------------------------------------------\n\n/**\n * The annotation key `property` stores a field's `Property` under.\n *\n * @since 0.1.0\n * @category annotations\n */\nexport const PropertyKey = '@thomasfosterau/effect-rdf/Resource/property';\n\n/**\n * The annotation key `describe` stores a struct's `Description` under.\n *\n * @since 0.1.0\n * @category annotations\n */\nexport const DescriptionKey = '@thomasfosterau/effect-rdf/Resource/description';\n\n/**\n * The annotation key `list` marks an array schema as an RDF collection with.\n *\n * @since 0.1.0\n * @category annotations\n */\nexport const ListKey = '@thomasfosterau/effect-rdf/Resource/list';\n\n/**\n * How a field reads its values: the direction of its predicate and, for\n * literals, the language tags it prefers.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface PropertyOptions {\n  /**\n   * Read the subjects of `?x predicate resource` instead of the objects of\n   * `resource predicate ?x` (and write such quads).\n   */\n  readonly inverse?: boolean | undefined;\n  /**\n   * Language tags in order of preference, `''` for an untagged value. A\n   * single-valued field takes the first value whose tag matches, trying the\n   * tags in order; a multi-valued field keeps the values whose tag is listed.\n   * Tags compare case-insensitively. Overrides `DecodeOptions.languages`.\n   */\n  readonly languages?: ReadonlyArray<string> | undefined;\n}\n\n/**\n * The predicate a field maps to, with its `PropertyOptions`: the value of the\n * `PropertyKey` annotation.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Property extends PropertyOptions {\n  readonly predicate: Term.NamedNode;\n}\n\n/**\n * What `describe` records about a struct: the `rdf:type` its resources carry\n * and the field holding the resource itself.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Description {\n  /**\n   * The class every resource of this shape is an instance of: decoding\n   * requires `resource rdf:type type`, encoding writes it, and `decodeAll`\n   * finds the resources by it.\n   */\n  readonly type?: Term.NamedNode | undefined;\n  /**\n   * The name of a field that holds the resource term itself (decoded through\n   * that field's codec, e.g. `TermCodec.namedNode` or `TermCodec.iri`). A\n   * nested value with an id encodes under it; one without becomes a fresh\n   * blank node.\n   */\n  readonly id?: string | undefined;\n}\n\n/**\n * Maps a struct field to a predicate: annotates `codec` with the predicate\n * (and `options`) without changing its type, so it composes with\n * `Schema.optional`, `Schema.Array` and `list` on either side.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const property = <S extends Schema.Top>(\n  predicate: Term.NamedNode,\n  codec: S,\n  options?: PropertyOptions,\n): S['Rebuild'] => {\n  const value: Property = { ...options, predicate };\n  return codec.annotate({ [PropertyKey]: value });\n};\n\n/**\n * Describes a struct as an RDF resource: the `rdf:type` it requires and\n * writes, and the field (if any) holding the resource term.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const describe =\n  (description: Description) =>\n  <S extends Schema.Top>(self: S): S['Rebuild'] =>\n    self.annotate({ [DescriptionKey]: description });\n\n/**\n * An array read from and written to an RDF collection (an `rdf:first` /\n * `rdf:rest` list ending in `rdf:nil`) instead of repeated objects.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const list = <S extends Schema.Top>(item: S): Schema.$Array<S> =>\n  Schema.Array(item).annotate({ [ListKey]: true });\n\n// -----------------------------------------------------------------------------\n// Options\n// -----------------------------------------------------------------------------\n\n/**\n * Options for `decode`, `decodeAll` and `schema`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface DecodeOptions {\n  /** The graph to read (every graph when omitted). */\n  readonly graph?: Term.Graph | undefined;\n  /** The default `PropertyOptions.languages` of every field. */\n  readonly languages?: ReadonlyArray<string> | undefined;\n  /** Passed to the struct's decoder (e.g. `{ errors: 'all' }`). */\n  readonly parseOptions?: SchemaAST.ParseOptions | undefined;\n}\n\n/**\n * Options for `encode` and `schema`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface EncodeOptions {\n  /** The graph to write the quads into (the default graph when omitted). */\n  readonly graph?: Term.Graph | undefined;\n  /** Passed to the struct's encoder. */\n  readonly parseOptions?: SchemaAST.ParseOptions | undefined;\n}\n\n/**\n * One resource `decodeAll` found and decoded.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Decoded<A> {\n  readonly subject: Term.Subject;\n  readonly value: A;\n}\n\n// -----------------------------------------------------------------------------\n// Field plans\n// -----------------------------------------------------------------------------\n\ntype Cardinality = 'one' | 'many' | 'list';\n\n// A struct field's name; numeric keys are not fields of a resource.\ntype Key = string | symbol;\n\nconst keyOf = (signature: SchemaAST.PropertySignature): Option.Option<Key> =>\n  Predicate.isNumber(signature.name) ? Option.none() : Option.some(signature.name);\n\ninterface Field {\n  readonly name: Key;\n  readonly property: Property;\n  readonly cardinality: Cardinality;\n  /** The key may be absent: `Schema.optional` / `Schema.optionalKey`. */\n  readonly optional: boolean;\n  /** The schema of one value. */\n  readonly item: SchemaAST.AST;\n}\n\nconst propertyOf = SchemaAST.resolveAt<Property>(PropertyKey);\nconst descriptionOf = SchemaAST.resolveAt<Description>(DescriptionKey);\nconst isList = (ast: SchemaAST.AST): boolean => SchemaAST.resolveAt<boolean>(ListKey)(ast) === true;\n\nconst resolveSuspend = (ast: SchemaAST.AST): SchemaAST.AST =>\n  SchemaAST.isSuspend(ast) ? resolveSuspend(ast.thunk()) : ast;\n\n// `T | undefined` (what `Schema.optional` wraps a field in) without the `undefined`.\nconst withoutUndefined = (ast: SchemaAST.AST): SchemaAST.AST => {\n  if (!SchemaAST.isUnion(ast)) return ast;\n  const defined = Arr.filter(ast.types, (t) => !SchemaAST.isUndefined(t));\n  return defined.length === 1 && defined.length < ast.types.length\n    ? Option.getOrElse(Arr.head(defined), () => ast)\n    : ast;\n};\n\n// An array of encoded values (`Schema.Array(codec)`), as opposed to a codec whose type is an array.\nconst arrayItem = (ast: SchemaAST.AST): Option.Option<SchemaAST.AST> =>\n  SchemaAST.isArrays(ast) && ast.encoding === undefined && Arr.isReadonlyArrayEmpty(ast.elements)\n    ? Arr.head(ast.rest)\n    : Option.none();\n\n// A nested resource: a struct whose encoded side is itself a record of terms.\nconst nestedStruct = (ast: SchemaAST.AST): Option.Option<SchemaAST.Objects> => {\n  const resolved = resolveSuspend(ast);\n  return SchemaAST.isObjects(resolved) && resolved.encoding === undefined\n    ? Option.some(resolved)\n    : Option.none();\n};\n\nconst fieldOf = (signature: SchemaAST.PropertySignature): Option.Option<Field> =>\n  Option.flatMap(keyOf(signature), (name) => fieldNamed(name, signature));\n\nconst fieldNamed = (name: Key, signature: SchemaAST.PropertySignature): Option.Option<Field> => {\n  const declared = signature.type;\n  const optional = SchemaAST.isOptional(declared);\n  const inner = withoutUndefined(declared);\n  const element = arrayItem(inner);\n  const annotated = Arr.getSomes([\n    Option.fromUndefinedOr(propertyOf(declared)),\n    Option.fromUndefinedOr(propertyOf(inner)),\n    Option.flatMap(element, (e) => Option.fromUndefinedOr(propertyOf(e))),\n  ]);\n  return Option.map(Arr.head(annotated), (found) =>\n    Option.match(element, {\n      onNone: () => ({\n        name,\n        property: found,\n        cardinality: 'one' as const,\n        optional,\n        item: inner,\n      }),\n      onSome: (item) => ({\n        name,\n        property: found,\n        cardinality: isList(inner) ? ('list' as const) : ('many' as const),\n        optional,\n        item,\n      }),\n    }),\n  );\n};\n\nconst expectStruct = (ast: SchemaAST.AST): Effect.Effect<SchemaAST.Objects, SchemaIssue.Issue> =>\n  Effect.mapError(\n    Effect.fromOption(nestedStruct(ast)),\n    () =>\n      new SchemaIssue.InvalidValue({\n        message: 'Expected a struct schema (Schema.Struct) to map a resource to',\n      }),\n  );\n\nconst describedType = (ast: SchemaAST.AST): Option.Option<Term.NamedNode> =>\n  Option.fromUndefinedOr(descriptionOf(ast)?.type);\n\nconst describedId = (ast: SchemaAST.AST): Option.Option<string> =>\n  Option.fromUndefinedOr(descriptionOf(ast)?.id);\n\n// -----------------------------------------------------------------------------\n// Decoding\n// -----------------------------------------------------------------------------\n\ninterface DecodeContext {\n  readonly dataset: Dataset.Dataset;\n  readonly options: DecodeOptions;\n}\n\ntype Visit = readonly [SchemaAST.AST, Term.Subject];\n\nconst languageOf = (term: Term.Term): string =>\n  Term.isLiteral(term) ? LanguageTag.normalize(term.language) : '';\n\nconst hasLanguage =\n  (tag: string) =>\n  (term: Term.Term): boolean =>\n    languageOf(term) === LanguageTag.normalize(tag);\n\n// The values of a field, before cardinality: sorted for determinism, then narrowed by language.\nconst valuesOf = (\n  context: DecodeContext,\n  subject: Term.Subject,\n  field: Field,\n): ReadonlyArray<Term.Object> => {\n  const { predicate, inverse } = field.property;\n  const terms: ReadonlyArray<Term.Object> =\n    inverse === true\n      ? Dataset.subjectsOf(context.dataset, predicate, subject, context.options.graph)\n      : Dataset.objectsOf(context.dataset, subject, predicate, context.options.graph);\n  const sorted = Arr.sort(terms, Term.Order);\n  const languages = field.property.languages ?? context.options.languages;\n  if (languages === undefined) return sorted;\n  if (field.cardinality === 'one') {\n    return Arr.fromOption(\n      Arr.findFirst(languages, (tag) => Arr.findFirst(sorted, hasLanguage(tag))),\n    );\n  }\n  return Arr.dedupe(Arr.flatMap(languages, (tag) => Arr.filter(sorted, hasLanguage(tag))));\n};\n\nconst describePredicate = (field: Field): string =>\n  field.property.inverse === true\n    ? `^${field.property.predicate.toString()}`\n    : field.property.predicate.toString();\n\nconst atField =\n  (field: Field, ...path: ReadonlyArray<PropertyKey>) =>\n  (issue: SchemaIssue.Issue): SchemaIssue.Issue =>\n    new SchemaIssue.Pointer([field.name, ...path], issue);\n\nconst missing = (field: Field): SchemaIssue.Issue =>\n  atField(field)(\n    new SchemaIssue.MissingKey({\n      messageMissingKey: `Missing value for ${describePredicate(field)}`,\n      predicate: field.property.predicate.value,\n    }),\n  );\n\nconst tooMany = (field: Field, values: ReadonlyArray<Term.Object>): SchemaIssue.Issue =>\n  atField(field)(\n    new SchemaIssue.InvalidValue(\n      {\n        message: `Expected ${field.optional ? 'at most' : 'exactly'} one value for ${describePredicate(field)}, got ${values.length}`,\n        predicate: field.property.predicate.value,\n      },\n      values,\n    ),\n  );\n\nconst isSubjectTerm = (term: Term.Term): term is Term.Subject => Term.isSubject(term);\n\n// The encoded value of one field value: the term, or a nested resource's record.\nconst encodedValue = (\n  context: DecodeContext,\n  item: SchemaAST.AST,\n  term: Term.Object,\n  visits: ReadonlyArray<Visit>,\n): Effect.Effect<unknown, SchemaIssue.Issue> =>\n  Option.match(nestedStruct(item), {\n    onNone: () => Effect.succeed(term),\n    onSome: () =>\n      isSubjectTerm(term)\n        ? gather(context, item, term, visits)\n        : Effect.fail(\n            new SchemaIssue.InvalidValue(\n              { message: `Expected an IRI or blank node, got ${term.toString()}` },\n              term,\n            ),\n          ),\n  });\n\nconst encodedValues = (\n  context: DecodeContext,\n  field: Field,\n  terms: ReadonlyArray<Term.Object>,\n  visits: ReadonlyArray<Visit>,\n): Effect.Effect<ReadonlyArray<unknown>, SchemaIssue.Issue> =>\n  Effect.forEach(\n    terms,\n    (term, index) =>\n      Effect.mapError(encodedValue(context, field.item, term, visits), atField(field, index)),\n    { concurrency: 1 },\n  );\n\nconst listItems = (\n  context: DecodeContext,\n  field: Field,\n  head: Term.Object,\n): Effect.Effect<ReadonlyArray<Term.Object>, SchemaIssue.Issue> =>\n  Effect.mapError(\n    Effect.fromOption(Dataset.list(context.dataset, head, context.options.graph)),\n    () =>\n      atField(field)(\n        new SchemaIssue.InvalidValue(\n          {\n            message: `Expected an RDF list for ${describePredicate(field)}, got ${head.toString()}`,\n            predicate: field.property.predicate.value,\n          },\n          head,\n        ),\n      ),\n  );\n\n// The encoded value of a field (`None` leaves the key out), checking its cardinality.\nconst encodedField = (\n  context: DecodeContext,\n  subject: Term.Subject,\n  field: Field,\n  visits: ReadonlyArray<Visit>,\n): Effect.Effect<Option.Option<unknown>, SchemaIssue.Issue> => {\n  const values = valuesOf(context, subject, field);\n  if (field.cardinality === 'many') {\n    return Arr.isReadonlyArrayEmpty(values) && field.optional\n      ? Effect.succeedNone\n      : Effect.asSome(encodedValues(context, field, values, visits));\n  }\n  return Arr.match(values, {\n    onEmpty: () => (field.optional ? Effect.succeedNone : Effect.fail(missing(field))),\n    onNonEmpty: ([first, ...rest]) => {\n      if (Arr.isArrayNonEmpty(rest)) return Effect.fail(tooMany(field, values));\n      return field.cardinality === 'list'\n        ? Effect.asSome(\n            Effect.flatMap(listItems(context, field, first), (items) =>\n              encodedValues(context, field, items, visits),\n            ),\n          )\n        : Effect.asSome(\n            Effect.mapError(encodedValue(context, field.item, first, visits), atField(field)),\n          );\n    },\n  });\n};\n\nconst hasType = (\n  context: DecodeContext,\n  subject: Term.Subject,\n  type: Term.NamedNode,\n): Effect.Effect<void, SchemaIssue.Issue> =>\n  Arr.isReadonlyArrayNonEmpty(\n    Dataset.match(context.dataset, {\n      subject,\n      predicate: rdf.type,\n      object: type,\n      graph: context.options.graph,\n    }),\n  )\n    ? Effect.void\n    : Effect.fail(\n        new SchemaIssue.InvalidValue(\n          {\n            message: `Expected ${subject.toString()} to have rdf:type ${type.toString()}`,\n            predicate: rdf.type.value,\n          },\n          subject,\n        ),\n      );\n\n// The encoded record of a resource: every mapped field's terms (or nested records), so the\n// struct's own decoder turns it into the struct's type.\nconst gather = (\n  context: DecodeContext,\n  ast: SchemaAST.AST,\n  subject: Term.Subject,\n  visits: ReadonlyArray<Visit>,\n): Effect.Effect<Record.ReadonlyRecord<Key, unknown>, SchemaIssue.Issue> =>\n  Effect.gen(function* () {\n    const struct = yield* expectStruct(ast);\n    if (Arr.some(visits, ([seen, at]) => seen === struct && Equal.equals(at, subject))) {\n      return yield* Effect.fail(\n        new SchemaIssue.InvalidValue(\n          { message: `Cycle: ${subject.toString()} is already being decoded as this resource` },\n          subject,\n        ),\n      );\n    }\n    yield* Option.match(describedType(struct), {\n      onNone: () => Effect.void,\n      onSome: (type) => hasType(context, subject, type),\n    });\n    const id = describedId(struct);\n    const inner: ReadonlyArray<Visit> = [...visits, [struct, subject]];\n    const entries = yield* Effect.forEach(\n      struct.propertySignatures,\n      (signature): Effect.Effect<Option.Option<readonly [Key, unknown]>, SchemaIssue.Issue> =>\n        Option.match(keyOf(signature), {\n          onNone: () => Effect.succeedNone,\n          onSome: (name) =>\n            Option.contains(id, name)\n              ? Effect.succeedSome([name, subject])\n              : Option.match(fieldNamed(name, signature), {\n                  onNone: () => Effect.succeedNone,\n                  onSome: (field) =>\n                    Effect.map(\n                      encodedField(context, subject, field, inner),\n                      Option.map((value) => [name, value]),\n                    ),\n                }),\n        }),\n      { concurrency: 1 },\n    );\n    return Record.fromEntries(Arr.getSomes(entries));\n  });\n\nconst contextOf = (dataset: Dataset.Dataset, options: DecodeOptions): DecodeContext => ({\n  dataset,\n  options,\n});\n\nconst decodeIssue = <S extends Schema.Constraint>(\n  schema: S,\n  dataset: Dataset.Dataset,\n  subject: Term.Subject,\n  options: DecodeOptions,\n  parseOptions?: SchemaAST.ParseOptions,\n): Effect.Effect<S['Type'], SchemaIssue.Issue, S['DecodingServices']> =>\n  Effect.flatMap(gather(contextOf(dataset, options), schema.ast, subject, []), (record) =>\n    SchemaParser.decodeEffect(schema)(record, parseOptions ?? options.parseOptions),\n  );\n\nconst toSchemaError = (issue: SchemaIssue.Issue): Schema.SchemaError =>\n  new Schema.SchemaError(issue);\n\n/**\n * Decodes the resource `subject` of `dataset` with a struct of `property`\n * fields: reads each field's values, checks their number against the field's\n * cardinality, decodes nested resources recursively and runs the struct's\n * decoder over the result.\n *\n * @since 0.1.0\n * @category decoding\n */\nexport const decode =\n  <S extends Schema.Constraint>(schema: S) =>\n  (\n    dataset: Dataset.Dataset,\n    subject: Term.Subject,\n    options?: DecodeOptions,\n  ): Effect.Effect<S['Type'], Schema.SchemaError, S['DecodingServices']> =>\n    Effect.mapError(decodeIssue(schema, dataset, subject, options ?? {}), toSchemaError);\n\n/**\n * Decodes every resource whose `rdf:type` is the struct's described `type`\n * (in `Term.Order` of the subjects). Fails on the first resource that does\n * not decode, with the subject at the head of the issue's path; fails when\n * the struct has no described `type`.\n *\n * @since 0.1.0\n * @category decoding\n */\nexport const decodeAll =\n  <S extends Schema.Constraint>(schema: S) =>\n  (\n    dataset: Dataset.Dataset,\n    options?: DecodeOptions,\n  ): Effect.Effect<ReadonlyArray<Decoded<S['Type']>>, Schema.SchemaError, S['DecodingServices']> =>\n    Option.match(describedType(schema.ast), {\n      onNone: () =>\n        Effect.fail(\n          toSchemaError(\n            new SchemaIssue.InvalidValue({\n              message: 'Resource.decodeAll needs a struct described with a type',\n            }),\n          ),\n        ),\n      onSome: (type) =>\n        Effect.forEach(\n          Arr.sort(Dataset.subjectsOf(dataset, rdf.type, type, options?.graph), Term.Order),\n          (subject) =>\n            Effect.mapBoth(decodeIssue(schema, dataset, subject, options ?? {}), {\n              onFailure: (issue) => toSchemaError(new SchemaIssue.Pointer([subject.key], issue)),\n              onSuccess: (value): Decoded<S['Type']> => ({ subject, value }),\n            }),\n          { concurrency: 1 },\n        ),\n    });\n\n// -----------------------------------------------------------------------------\n// Encoding\n// -----------------------------------------------------------------------------\n\ninterface Emitted {\n  readonly subject: Term.Subject;\n  readonly quads: ReadonlyArray<Term.Quad>;\n}\n\n// What a struct encodes to: one entry per field.\ntype EncodedRecord = Record.ReadonlyRecord<Key, unknown>;\n\nconst isEncodedRecord = (u: unknown): u is EncodedRecord =>\n  Predicate.isObject(u) && !Term.isTerm(u);\n\nconst read = (record: EncodedRecord, key: Key): Option.Option<unknown> =>\n  Option.filter(Record.get(record, key), Predicate.isNotUndefined);\n\nconst unexpected = (expected: string): SchemaIssue.Issue =>\n  new SchemaIssue.InvalidValue({ message: `Expected the codec to encode to ${expected}` });\n\nconst statement = (\n  field: Field,\n  subject: Term.Subject,\n  value: Term.Object,\n  graph: Term.Graph,\n): Effect.Effect<Term.Quad, SchemaIssue.Issue> => {\n  const predicate = field.property.predicate;\n  if (field.property.inverse !== true) {\n    return Effect.succeed(new Term.Quad(subject, predicate, value, graph));\n  }\n  return isSubjectTerm(value)\n    ? Effect.succeed(new Term.Quad(value, predicate, subject, graph))\n    : Effect.fail(\n        atField(field)(\n          new SchemaIssue.InvalidValue(\n            {\n              message: `Expected an IRI or blank node for ${describePredicate(field)}, got ${value.toString()}`,\n              predicate: predicate.value,\n            },\n            value,\n          ),\n        ),\n      );\n};\n\n// An RDF collection of `items`: its head and the `rdf:first` / `rdf:rest` quads.\nconst collection = (\n  items: ReadonlyArray<Term.Object>,\n  graph: Term.Graph,\n): readonly [Term.Object, ReadonlyArray<Term.Quad>] => {\n  const nodes = Arr.map(items, () => Term.blankNode());\n  const rests: ReadonlyArray<Term.Object> = [...Arr.drop(nodes, 1), rdf.nil];\n  const quads = Arr.flatMap(Arr.zip(nodes, Arr.zip(items, rests)), ([node, [item, rest]]) => [\n    new Term.Quad(node, rdf.first, item, graph),\n    new Term.Quad(node, rdf.rest, rest, graph),\n  ]);\n  return [Option.getOrElse(Arr.head(nodes), (): Term.Object => rdf.nil), quads];\n};\n\n// The term for one encoded value of a field, with the quads of a nested resource.\ntype Emittable = readonly [Term.Object, ReadonlyArray<Term.Quad>];\n\n// The statements of one field of `record`, with the quads of its nested resources.\nconst emitField = (\n  field: Field,\n  subject: Term.Subject,\n  record: EncodedRecord,\n  graph: Term.Graph,\n): Effect.Effect<ReadonlyArray<Term.Quad>, SchemaIssue.Issue> =>\n  Effect.gen(function* () {\n    const items: ReadonlyArray<unknown> = Option.match(read(record, field.name), {\n      onNone: () => [],\n      onSome: (v) => (field.cardinality !== 'one' && Arr.isArray(v) ? v : [v]),\n    });\n    const nested = nestedStruct(field.item);\n    const emitted = yield* Effect.forEach(\n      items,\n      (item, index): Effect.Effect<Emittable, SchemaIssue.Issue> => {\n        const at = field.cardinality === 'one' ? atField(field) : atField(field, index);\n        return Option.match(nested, {\n          onNone: () =>\n            Term.isObject(item)\n              ? Effect.succeed([item, []])\n              : Effect.fail(at(unexpected('an RDF term'))),\n          onSome: (struct) =>\n            isEncodedRecord(item)\n              ? Effect.mapBoth(emit(struct, Option.none(), item, graph), {\n                  onFailure: at,\n                  onSuccess: (out): Emittable => [out.subject, out.quads],\n                })\n              : Effect.fail(at(unexpected('a record'))),\n        });\n      },\n      { concurrency: 1 },\n    );\n    const inner = Arr.flatMap(emitted, ([, quads]) => quads);\n    const terms = Arr.map(emitted, ([term]) => term);\n    if (field.cardinality === 'list' && Option.isSome(read(record, field.name))) {\n      const [head, links] = collection(terms, graph);\n      const link = yield* statement(field, subject, head, graph);\n      return [link, ...links, ...inner];\n    }\n    const links = yield* Effect.forEach(terms, (term) => statement(field, subject, term, graph), {\n      concurrency: 1,\n    });\n    return [...links, ...inner];\n  });\n\n// The quads of an encoded record: its type, each mapped field's statements and nested resources.\nconst emit = (\n  struct: SchemaAST.Objects,\n  given: Option.Option<Term.Subject>,\n  record: EncodedRecord,\n  graph: Term.Graph,\n): Effect.Effect<Emitted, SchemaIssue.Issue> =>\n  Effect.gen(function* () {\n    const id = describedId(struct);\n    const subject = Option.getOrElse(\n      Option.orElse(given, () =>\n        Option.filter(\n          Option.flatMap(id, (key) => read(record, key)),\n          (term): term is Term.Subject => Term.isSubject(term),\n        ),\n      ),\n      (): Term.Subject => Term.blankNode(),\n    );\n    const typed = Arr.map(\n      Arr.fromOption(describedType(struct)),\n      (type) => new Term.Quad(subject, rdf.type, type, graph),\n    );\n    const fields = Arr.filter(\n      Arr.getSomes(Arr.map(struct.propertySignatures, fieldOf)),\n      (field) => !Option.contains(id, field.name),\n    );\n    const quads = yield* Effect.forEach(\n      fields,\n      (field) => emitField(field, subject, record, graph),\n      { concurrency: 1 },\n    );\n    return { subject, quads: [...typed, ...Arr.flatten(quads)] };\n  });\n\nconst encodeIssue = <S extends Schema.Constraint>(\n  schema: S,\n  subject: Option.Option<Term.Subject>,\n  value: S['Type'],\n  options: EncodeOptions,\n  parseOptions?: SchemaAST.ParseOptions,\n): Effect.Effect<Emitted, SchemaIssue.Issue, S['EncodingServices']> =>\n  Effect.gen(function* () {\n    const struct = yield* expectStruct(schema.ast);\n    const record = yield* SchemaParser.encodeEffect(schema)(\n      value,\n      parseOptions ?? options.parseOptions,\n    );\n    return isEncodedRecord(record)\n      ? yield* emit(struct, subject, record, options.graph ?? Term.defaultGraph)\n      : yield* Effect.fail(unexpected('a record'));\n  });\n\n/**\n * Encodes `value` as the resource `subject`: the struct's encoder turns each\n * field into terms, written as `subject predicate term` quads (or\n * `term predicate subject` for an `inverse` field), with an `rdf:type` quad\n * for a described type, RDF collections for `list` fields and the quads of\n * nested resources.\n *\n * @since 0.1.0\n * @category encoding\n */\nexport const encode =\n  <S extends Schema.Constraint>(schema: S) =>\n  (\n    subject: Term.Subject,\n    value: S['Type'],\n    options?: EncodeOptions,\n  ): Effect.Effect<ReadonlyArray<Term.Quad>, Schema.SchemaError, S['EncodingServices']> =>\n    Effect.mapBoth(encodeIssue(schema, Option.some(subject), value, options ?? {}), {\n      onFailure: toSchemaError,\n      onSuccess: (out) => out.quads,\n    });\n\n// -----------------------------------------------------------------------------\n// Schema form\n// -----------------------------------------------------------------------------\n\n/**\n * A subject term: an IRI, blank node or triple term.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const SubjectSchema: Schema.Union<\n  readonly [\n    Schema.declare<Term.NamedNode>,\n    Schema.declare<Term.BlankNode>,\n    Schema.declare<Term.Triple>,\n  ]\n> = Schema.Union([Term.NamedNodeSchema, Term.BlankNodeSchema, Term.TripleSchema]);\n\n/**\n * The type `SubjectSchema` decodes to: `Term.Subject`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type SubjectSchema = typeof SubjectSchema.Type;\n\n/**\n * The encoded side of `schema`: a dataset and the resource in it.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const InputSchema: Schema.Struct<{\n  readonly dataset: Schema.declare<Dataset.Dataset>;\n  readonly subject: typeof SubjectSchema;\n}> = Schema.Struct({ dataset: Dataset.DatasetSchema, subject: SubjectSchema });\n\n/**\n * The type `InputSchema` decodes to: `{ dataset, subject }`.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport type InputSchema = typeof InputSchema.Type;\n\n/**\n * The `Schema` form of `decode` / `encode`: decodes `{ dataset, subject }`\n * to the struct's type, and encodes a value to the dataset of its quads with\n * the resource as `subject` (its `describe`d id, or a fresh blank node). It\n * composes with `Schema.decodeTo`, `Schema.decodeUnknownEffect` and the rest\n * of the `Schema` API.\n *\n * @since 0.1.0\n * @category schemas\n */\nexport const schema = <S extends Schema.Top>(\n  self: S,\n  options?: DecodeOptions & EncodeOptions,\n): Schema.decodeTo<\n  Schema.toType<S>,\n  typeof InputSchema,\n  S['DecodingServices'],\n  S['EncodingServices']\n> =>\n  InputSchema.pipe(\n    Schema.decodeTo(\n      Schema.toType(self),\n      SchemaTransformation.transformEffect<\n        S['Type'],\n        InputSchema,\n        S['DecodingServices'],\n        S['EncodingServices']\n      >({\n        decode: (input, parseOptions) =>\n          decodeIssue(self, input.dataset, input.subject, options ?? {}, parseOptions),\n        encode: (value, parseOptions) =>\n          Effect.map(\n            encodeIssue(self, Option.none(), value, options ?? {}, parseOptions),\n            (out): InputSchema => ({\n              dataset: Dataset.fromIterable(out.quads),\n              subject: out.subject,\n            }),\n          ),\n      }),\n    ),\n  );\n"],"mappings":"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"}

package/dist/Resource.d.mts

@@ -0,0 +1,2 @@
+import { _ as list, a as EncodeOptions, c as Property, f as SubjectSchema, g as encode, h as describe, i as DescriptionKey, l as PropertyKey, m as decodeAll, n as Decoded, o as InputSchema, p as decode, r as Description, s as ListKey, t as DecodeOptions, u as PropertyOptions, v as property, y as schema } from "./Resource-B1cI8FyJ.mjs";
+export { DecodeOptions, Decoded, Description, DescriptionKey, EncodeOptions, InputSchema, ListKey, Property, PropertyKey, PropertyOptions, SubjectSchema, decode, decodeAll, describe, encode, list, property, schema };

package/dist/Resource.mjs

@@ -0,0 +1 @@
+export { t as DescriptionKey, n as InputSchema, r as ListKey, i as PropertyKey, o as SubjectSchema, s as decode, c as decodeAll, l as describe, u as encode, d as list, f as property, p as schema } from "./Resource-sIEeNh15.mjs";

package/dist/Results-BVNEC-Wt.d.mts

@@ -0,0 +1,277 @@
+import { a as GroundTerm } from "./TermJson-BOPe0yve.mjs";
+import { _ as Quad, j as Variable, s as GroundTerm$1 } from "./Term-B_4ezyXq.mjs";
+import { t as Bindings$1 } from "./Bindings-DiKpBd7f.mjs";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+declare namespace Results_d_exports {
+  export { AskResult, BooleanResult, Csv, GraphResult, Json, JsonResults, JsonResultsSchema, JsonTerm, JsonTermSchema, ParsedResult, QueryResult, ResultSet, ResultsCodec, ResultsFormat, ResultsParseError, SelectResult, Tsv, Xml, codecFor, codecForExtension, codecs, collect, fromResultSet, negotiate, parseTerm, termFromJson, termToJson, termToTsv };
+}
+type Bindings = Bindings$1;
+/**
+ * The result of a `SELECT` query: the projected variables and a (lazy)
+ * stream of solutions.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SelectResult<E = never> {
+  readonly _tag: 'Select';
+  readonly variables: ReadonlyArray<Variable>;
+  readonly bindings: Stream.Stream<Bindings, E>;
+}
+/**
+ * The result of an `ASK` query.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface AskResult {
+  readonly _tag: 'Ask';
+  readonly value: boolean;
+}
+/**
+ * The result of a `CONSTRUCT` or `DESCRIBE` query: a (lazy, duplicate-free)
+ * stream of triples (as quads in the default graph).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface GraphResult<E = never> {
+  readonly _tag: 'Graph';
+  readonly quads: Stream.Stream<Quad, E>;
+}
+/**
+ * Any query result.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type QueryResult<E = never> = SelectResult<E> | AskResult | GraphResult<E>;
+/**
+ * A fully materialised solution sequence (e.g. a parsed results document).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ResultSet {
+  readonly _tag: 'ResultSet';
+  readonly variables: ReadonlyArray<string>;
+  readonly bindings: ReadonlyArray<Bindings>;
+}
+/**
+ * A boolean (`ASK`) result document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface BooleanResult {
+  readonly _tag: 'Boolean';
+  readonly value: boolean;
+}
+/**
+ * A parsed results document.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type ParsedResult = ResultSet | BooleanResult;
+/**
+ * Materialises a `SELECT` result.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const collect: <E>(result: SelectResult<E>) => Effect.Effect<ResultSet, E>;
+/**
+ * Turns a materialised result set back into a streaming `SelectResult`.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const fromResultSet: (set: ResultSet) => SelectResult;
+declare const ResultsParseError_base: Schema.Class<ResultsParseError, Schema.TaggedStruct<"ResultsParseError", {
+  readonly format: Schema.String;
+  readonly message: Schema.String;
+  readonly line: Schema.optional<Schema.Number>;
+  readonly column: Schema.optional<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An error parsing a results document. The text formats (TSV and CSV)
+ * report the 1-based `line` and `column` of the error.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class ResultsParseError extends ResultsParseError_base {}
+/**
+ * Metadata of a results format.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ResultsFormat {
+  readonly name: string;
+  readonly mediaType: string;
+  readonly mediaTypes: ReadonlyArray<string>;
+  readonly extensions: ReadonlyArray<string>;
+  /** Whether the format can represent boolean (`ASK`) results. */
+  readonly booleans: boolean;
+}
+/**
+ * A results format: streaming serialiser and parser.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ResultsCodec {
+  readonly format: ResultsFormat;
+  /** Serialises a (streaming) select or ask result to text chunks. */
+  readonly serialize: <E>(result: SelectResult<E> | AskResult) => Stream.Stream<string, E>;
+  /** Serialises a materialised result to a string. */
+  readonly serializeString: (result: ParsedResult | AskResult) => string;
+  /** Parses a complete document. */
+  readonly parse: (input: string) => Effect.Effect<ParsedResult, ResultsParseError>;
+}
+/**
+ * The JSON encoding of an RDF term in SPARQL results (re-exported from core's
+ * `TermJson.GroundTerm`).
+ *
+ * @since 0.1.0
+ * @category json
+ */
+type JsonTerm = GroundTerm;
+/**
+ * Schema of an RDF term in SPARQL JSON results (SPARQL 1.2, including
+ * triple terms; core's `TermJson.GroundTermSchema`).
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare const JsonTermSchema: Schema.Codec<JsonTerm>;
+/**
+ * The type `JsonTermSchema` decodes to (the same as `JsonTerm`).
+ *
+ * @since 0.1.0
+ * @category json
+ */
+type JsonTermSchema = typeof JsonTermSchema.Type;
+/**
+ * Schema of a SPARQL JSON results document.
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare const JsonResultsSchema: Schema.Struct<{
+  readonly head: Schema.Struct<{
+    readonly vars: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly link: Schema.optional<Schema.$Array<Schema.String>>;
+  }>;
+  readonly results: Schema.optional<Schema.Struct<{
+    readonly bindings: Schema.$Array<Schema.$Record<Schema.String, Schema.Codec<GroundTerm, GroundTerm, never, never>>>;
+  }>>;
+  readonly boolean: Schema.optional<Schema.Boolean>;
+}>;
+/**
+ * @since 0.1.0
+ * @category json
+ */
+type JsonResults = typeof JsonResultsSchema.Type;
+/**
+ * The type `JsonResultsSchema` decodes to (the same as `JsonResults`).
+ *
+ * @since 0.1.0
+ * @category json
+ */
+type JsonResultsSchema = typeof JsonResultsSchema.Type;
+/**
+ * Encodes a term as SPARQL JSON (core's `Term.toJson`).
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare const termToJson: (t: GroundTerm$1) => JsonTerm;
+/**
+ * Decodes a SPARQL JSON term (core's `Term.fromJson`); the positions of a
+ * triple term are trusted.
+ *
+ * @since 0.1.0
+ * @category json
+ */
+declare const termFromJson: (j: JsonTerm) => GroundTerm$1;
+/**
+ * SPARQL 1.1 Query Results JSON Format.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const Json: ResultsCodec;
+/**
+ * SPARQL Query Results XML Format.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const Xml: ResultsCodec;
+/**
+ * Formats a term in the Turtle / SPARQL syntax used by TSV results.
+ *
+ * @since 0.1.0
+ * @category tsv
+ */
+declare const termToTsv: (t: GroundTerm$1) => string;
+/**
+ * Parses a term written in the Turtle / SPARQL syntax used by TSV results
+ * (IRIs in `<>`, blank nodes, quoted literals, numbers, booleans, triple
+ * terms).
+ *
+ * @since 0.1.0
+ * @category tsv
+ */
+declare const parseTerm: (text: string) => Option.Option<GroundTerm$1>;
+/**
+ * SPARQL 1.1 Query Results TSV Format.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const Tsv: ResultsCodec;
+/**
+ * SPARQL 1.1 Query Results CSV Format (lossy: parsing recovers IRIs, blank
+ * nodes, numbers and strings heuristically).
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const Csv: ResultsCodec;
+/**
+ * All results formats, in order of preference.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const codecs: ReadonlyArray<ResultsCodec>;
+/**
+ * Finds a results codec for a media type (parameters are ignored).
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const codecFor: (mediaType: string) => Option.Option<ResultsCodec>;
+/**
+ * Finds a results codec for a file extension.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const codecForExtension: (extension: string) => Option.Option<ResultsCodec>;
+/**
+ * Chooses the best results codec for an HTTP `Accept` header.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const negotiate: (accept: string | undefined) => Option.Option<ResultsCodec>;
+export { collect as C, termFromJson as D, parseTerm as E, termToJson as O, codecs as S, negotiate as T, SelectResult as _, Json as a, codecFor as b, JsonTerm as c, QueryResult as d, ResultSet as f, Results_d_exports as g, ResultsParseError as h, GraphResult as i, termToTsv as k, JsonTermSchema as l, ResultsFormat as m, BooleanResult as n, JsonResults as o, ResultsCodec as p, Csv as r, JsonResultsSchema as s, AskResult as t, ParsedResult as u, Tsv as v, fromResultSet as w, codecForExtension as x, Xml as y };
+//# sourceMappingURL=Results-BVNEC-Wt.d.mts.map