@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/Compiler.d.ts

@@ -1,16 +1,13 @@
 import type { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Generator } from "./generators/Generator.js";
-import type { TsFeature } from "./generators/ts/TsFeature.js";
 import type { ShapesGraph } from "./input/ShapesGraph.js";
 export declare class Compiler {
     private readonly generator;
     private readonly logger;
-    private readonly tsFeaturesDefault?;
     constructor({ generator, logger, }: {
         generator: Generator;
         logger: Logger;
-        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     compile(shapesGraph: ShapesGraph): Either<Error, string>;
 }

package/dist/Compiler.js

@@ -2,7 +2,6 @@ import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 export class Compiler {
     generator;
     logger;
-    tsFeaturesDefault;
     constructor({ generator, logger, }) {
         this.generator = generator;
         this.logger = logger;
@@ -11,7 +10,6 @@ export class Compiler {
         return new ShapesGraphToAstTransformer({
             logger: this.logger,
             shapesGraph,
-            tsFeaturesDefault: this.tsFeaturesDefault,
         })
             .transform()
             .map((ast) => this.generator.generate(ast));

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -3,7 +3,6 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type * as ast from "./ast/index.js";
-import type { TsFeature } from "./generators/ts/TsFeature.js";
 import type * as input from "./input/index.js";
 interface RelatedNodeShapes {
     readonly ancestors: input.NodeShape[];
@@ -16,11 +15,9 @@ export declare class ShapesGraphToAstTransformer {
     protected readonly logger: Logger;
     protected readonly shapesGraph: input.ShapesGraph;
     protected readonly relatedNodeShapesByIdentifier: TermMap<BlankNode | NamedNode, RelatedNodeShapes>;
-    protected tsFeaturesDefault: ReadonlySet<TsFeature>;
-    constructor({ logger, shapesGraph, tsFeaturesDefault, }: {
+    constructor({ logger, shapesGraph, }: {
         logger: Logger;
         shapesGraph: input.ShapesGraph;
-        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     transform(): Either<Error, ast.Ast>;
 }

package/dist/ShapesGraphToAstTransformer.js

@@ -77,17 +77,13 @@ export class ShapesGraphToAstTransformer {
     logger;
     shapesGraph;
     relatedNodeShapesByIdentifier = new TermMap();
-    tsFeaturesDefault;
-    constructor({ logger, shapesGraph, tsFeaturesDefault, }) {
+    constructor({ logger, shapesGraph, }) {
         this.logger = logger;
         this.relatedNodeShapesByIdentifier = relatedNodeShapes({
             logger: this.logger,
             shapesGraph,
         });
         this.shapesGraph = shapesGraph;
-        this.tsFeaturesDefault =
-            tsFeaturesDefault ??
-                new Set(["create", "equals", "hash", "json", "rdf"]);
     }
     transform() {
         const astNamedIntersectionTypes = [];

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstObjectTypeProperty.js

@@ -6,7 +6,7 @@ import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
-function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
+function synthesizePartialAstObjectType({ identifierType, }) {
     let syntheticName;
     switch (identifierType.kind) {
         case "BlankNodeType":
@@ -28,7 +28,6 @@ function synthesizePartialAstObjectType({ identifierType, tsFeatures, }) {
         shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
         synthetic: true,
         toRdfTypes: [],
-        tsFeatures,
         tsImports: [],
     });
 }
@@ -179,7 +178,6 @@ export function transformPropertyShapeToAstObjectTypeProperty({ objectType, prop
                 case "IriType":
                     astPartialItemType = synthesizePartialAstObjectType({
                         identifierType: astItemType,
-                        tsFeatures: astResolveItemType.tsFeatures,
                     });
                     break;
                 case "ObjectType":

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -2,7 +2,6 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
-import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { transformShapeToAstType } from "./transformShapeToAstType.js";
 /**
@@ -11,13 +10,11 @@ import { transformShapeToAstType } from "./transformShapeToAstType.js";
 export function transformShapeToAstCompoundType(shape, shapeStack) {
     shapeStack.push(shape);
     try {
-        return Eithers.chain3(Either.sequence(shape.and
+        return Eithers.chain2(Either.sequence(shape.and
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), shape.$type === "NodeShape"
-            ? nodeShapeTsFeatures.call(this, shape)
-            : Either.of(new Set()), Either.sequence(shape.xone
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.xone
             .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, tsFeatures, xoneConstraintShapes]) => {
+            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, xoneConstraintShapes]) => {
             let compoundTypeKind;
             // Distinguish constraints that take arbitrary shapes from those that only take node shapes
             // With the latter we'll do special transformations.
@@ -42,7 +39,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                 label: shape.label,
                 name: shapeAstTypeName(shape),
                 shapeIdentifier: shape.$identifier(),
-                tsFeatures,
+                synthetic: false,
             });
             if (memberShapes.length === 1) {
                 return transformShapeToAstType

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -20,7 +20,6 @@ const listPropertiesObjectType = new ast.ObjectType({
     fromRdfType: Maybe.empty(),
     name: Maybe.empty(),
     toRdfTypes: [],
-    tsFeatures: new Set([]),
     shapeIdentifier: dataFactory.blankNode(),
     synthetic: true,
     tsImports: [],

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstObjectType.js

@@ -4,7 +4,6 @@ import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
 import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
-import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
 import { ShapeStack } from "./ShapeStack.js";
 import { shapeAstTypeName } from "./shapeAstTypeName.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
@@ -60,7 +59,7 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
         if (nodeShape.$identifier().termType !== "NamedNode") {
             return Either.of(Maybe.empty());
         }
-        return Eithers.chain3(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))), nodeShapeTsFeatures.call(this, nodeShape)).chain(([nodeKinds, propertyShapes, tsFeatures]) => {
+        return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier)))).chain(([nodeKinds, propertyShapes]) => {
             const nodeShapeIdentifier = nodeShape.$identifier();
             const { ancestors: ancestorNodeShapes, descendants: descendantNodeShapes, children: childNodeShapes, parents: parentNodeShapes, } = this.relatedNodeShapesByIdentifier.get(nodeShapeIdentifier);
             const isClass = nodeShape.subClassOf.length > 0 ||
@@ -128,7 +127,6 @@ export function transformShapeToAstObjectType(shape, shapeStack) {
                 shapeIdentifier: nodeShape.$identifier(),
                 synthetic: false,
                 toRdfTypes,
-                tsFeatures,
                 tsImports: nodeShape.tsImports,
             });
             this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), objectType);

package/dist/ast/AbstractCompoundType.d.ts

@@ -1,5 +1,4 @@
 import type { NodeKind } from "@shaclmate/shacl-ast";
-import type { TsFeature } from "../generators/ts/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -22,13 +21,16 @@ export declare abstract class AbstractCompoundType<MemberT extends AbstractCompo
      * Type discriminant
      */
     abstract readonly kind: "IntersectionType" | "UnionType";
-    constructor({ tsFeatures, ...superParameters }: {
-        tsFeatures: ReadonlySet<TsFeature>;
+    /**
+     * Was this type synthesized or did it come from SHACL?
+     */
+    readonly synthetic: boolean;
+    constructor({ synthetic, ...superParameters }: {
+        synthetic: boolean;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get members(): readonly MemberT[];
     get nodeKinds(): ReadonlySet<NodeKind>;
     get recursive(): boolean;
-    get tsFeatures(): ReadonlySet<TsFeature>;
     addMember(member: MemberT): void;
     equals(other: AbstractCompoundType<MemberT, MemberTypeT>): boolean;
 }

package/dist/ast/AbstractCompoundType.js

@@ -20,12 +20,12 @@ export class AbstractCompoundType extends AbstractType {
      */
     #members = [];
     /**
-     * TypeScript features to generate.
+     * Was this type synthesized or did it come from SHACL?
      */
-    #tsFeatures;
-    constructor({ tsFeatures, ...superParameters }) {
+    synthetic;
+    constructor({ synthetic, ...superParameters }) {
         super(superParameters);
-        this.#tsFeatures = tsFeatures;
+        this.synthetic = synthetic;
     }
     get members() {
         return this.#members;
@@ -42,36 +42,6 @@ export class AbstractCompoundType extends AbstractType {
     get recursive() {
         return this.members.some((member) => member.type.recursive);
     }
-    get tsFeatures() {
-        // Members of the compound type must have the same tsFeatures.
-        // They must also have distinct RDF types or no RDF types at all.
-        const mergedMemberTsFeatures = new Set();
-        for (let memberI = 0; memberI < this.members.length; memberI++) {
-            const member = this.members[memberI];
-            switch (member.type.kind) {
-                case "IntersectionType":
-                case "ObjectType":
-                case "UnionType":
-                    break;
-                default:
-                    continue;
-            }
-            if (memberI === 0) {
-                for (const tsFeature of member.type.tsFeatures) {
-                    mergedMemberTsFeatures.add(tsFeature);
-                }
-            }
-            if (member.type.tsFeatures.size !== mergedMemberTsFeatures.size) {
-                throw new Error(`${this} has a member (${member}) with different tsFeatures than the other members`);
-            }
-            for (const tsFeature of member.type.tsFeatures) {
-                if (!mergedMemberTsFeatures.has(tsFeature)) {
-                    throw new Error(`${this} has a member (${member}) with different tsFeatures than the other members`);
-                }
-            }
-        }
-        return this.#tsFeatures;
-    }
     addMember(member) {
         this.#members.push(member);
     }
@@ -84,9 +54,6 @@ export class AbstractCompoundType extends AbstractType {
 __decorate([
     Memoize()
 ], AbstractCompoundType.prototype, "nodeKinds", null);
-__decorate([
-    Memoize()
-], AbstractCompoundType.prototype, "tsFeatures", null);
 (function (AbstractCompoundType) {
     function isMemberType(type) {
         switch (type.kind) {

package/dist/ast/ObjectType.d.ts

@@ -2,7 +2,6 @@ import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { PropertyPath } from "@rdfx/resource";
 import type { NodeKind } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { TsFeature } from "../generators/ts/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
@@ -43,10 +42,6 @@ export declare class ObjectType extends AbstractType {
      * class targets).
      */
     readonly toRdfTypes: readonly NamedNode[];
-    /**
-     * TypeScript features to generate.
-     */
-    readonly tsFeatures: ReadonlySet<TsFeature>;
     /**
      * TypeScript imports to add to generated code.
      *
@@ -56,13 +51,12 @@ export declare class ObjectType extends AbstractType {
      * import { MyType } from "./MyType.js"
      */
     readonly tsImports: readonly string[];
-    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, ...superParameters }: {
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsImports, ...superParameters }: {
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
-        tsFeatures: ReadonlySet<TsFeature>;
         tsImports: readonly string[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get ancestorObjectTypes(): readonly ObjectType[];

package/dist/ast/ObjectType.js

@@ -76,10 +76,6 @@ export class ObjectType extends AbstractType {
      * class targets).
      */
     toRdfTypes;
-    /**
-     * TypeScript features to generate.
-     */
-    tsFeatures;
     /**
      * TypeScript imports to add to generated code.
      *
@@ -89,14 +85,13 @@ export class ObjectType extends AbstractType {
      * import { MyType } from "./MyType.js"
      */
     tsImports;
-    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsFeatures, tsImports, ...superParameters }) {
+    constructor({ extern, fromRdfType, identifierType, synthetic, toRdfTypes, tsImports, ...superParameters }) {
         super(superParameters);
         this.extern = extern;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
-        this.tsFeatures = tsFeatures;
         this.tsImports = tsImports;
     }
     get ancestorObjectTypes() {

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -1,5 +1,6 @@
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import type { AbstractType } from "./AbstractType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
@@ -9,19 +10,21 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     protected readonly minCount: bigint;
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
-    readonly typeofs: NonEmptyList<"object">;
+    readonly typeofs: "object"[];
     constructor({ minCount, mutable, ...superParameters }: {
         minCount: bigint;
         mutable: boolean;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversions(): readonly AbstractContainerType.Conversion[];
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
+    get hashFunction(): Code;
     get mutable(): boolean;
     get name(): Code;
     get schemaType(): Code;
+    get validationFunction(): Maybe<Code>;
     protected get schemaObject(): {
         minCount: number | undefined;
         item: Code;
@@ -29,19 +32,17 @@ export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractC
     };
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
+    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractCollectionType {
-    type Conversion = AbstractContainerType.Conversion;
     type DiscriminantProperty = AbstractContainerType.DiscriminantProperty;
-    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractContainerType.GraphqlType;
     const isItemType: typeof AbstractContainerType.isItemType;
     type ItemType = AbstractContainerType.ItemType;
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    const JsonType: typeof AbstractType.JsonType;
     type JsonType = AbstractContainerType.JsonType;
 }
 //# sourceMappingURL=AbstractCollectionType.d.ts.map

package/dist/generators/ts/AbstractCollectionType.js

@@ -4,12 +4,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { codeEquals } from "./codeEquals.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for ListType and SetType.
  */
@@ -18,7 +17,7 @@ export class AbstractCollectionType extends AbstractContainerType {
     minCount;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    typeofs = NonEmptyList(["object"]);
+    typeofs = ["object"];
     constructor({ minCount, mutable, ...superParameters }) {
         super(superParameters);
         this.minCount = minCount;
@@ -28,91 +27,24 @@ export class AbstractCollectionType extends AbstractContainerType {
             invariant(this.minCount === 0n);
         }
     }
-    get conversions() {
-        const conversions = [];
-        // Try to do some conversions from types itemType can be converted to
-        // For example, if itemType is a NamedNode, it can be converted from a string, so here we'd accept:
-        // readonly NamedNode[] (no conversion)
-        // readonly string[] (map to NamedNodes)
-        // We only consider discriminating by (item) typeof. For example, the types above could be discriminated by the branches
-        // array.every(item => typeof item === "object")
-        // array.every(item => typeof item === "string")
-        const itemTypeConversionsByTypeof = {};
-        if (this.itemType.typeofs.length === 1) {
-            itemTypeConversionsByTypeof[this.itemType.typeofs[0]] = {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === ${this.itemType.typeofs[0]}`,
-                sourceTypeName: this.itemType.name,
-                sourceTypeof: this.itemType.typeofs[0],
-            };
-            for (const itemTypeConversion of this.itemType.conversions) {
-                if (!itemTypeConversionsByTypeof[itemTypeConversion.sourceTypeof]) {
-                    itemTypeConversionsByTypeof[itemTypeConversion.sourceTypeof] =
-                        itemTypeConversion;
-                }
-            }
-        }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        const sourceTypes = [
+            {
+                name: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.name}`), { on: " | " })})[]`,
+                typeof: "object",
+            },
+        ];
         if (this.minCount === 0n) {
-            if (Object.keys(itemTypeConversionsByTypeof).length <= 1) {
-                // There were no additional conversions with different item typeof's, so we don't need to check .every or do .map
-                // Just check that the original value is an array with typeof "object". Array.isArray() doesn't narrow types for some reason.
-                conversions.push({
-                    conversionExpression: (value) => 
-                    // Defensive copy
-                    code `${value}${this.mutable ? ".concat()" : ""}`,
-                    sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                    sourceTypeName: code `readonly (${this.itemType.name})[]`,
-                    sourceTypeof: "object",
-                });
-            }
-            else {
-                // There were additional conversions with different item typeof's.
-                // We do .every (per above) to discriminate array types with different item typeof's and .map to convert the array at runtime.
-                for (const [itemTypeof, itemTypeofConversion] of Object.entries(itemTypeConversionsByTypeof)) {
-                    const itemVariable = code `item`;
-                    conversions.push({
-                        conversionExpression: (value) => {
-                            const itemTypeConversionExpression = itemTypeofConversion.conversionExpression(itemVariable);
-                            return !codeEquals(itemTypeConversionExpression, itemVariable)
-                                ? code `${value}.map(item => ${itemTypeConversionExpression})`
-                                : // Defensive copy
-                                    code `${value}${this.mutable ? ".concat()" : ""}`;
-                        },
-                        sourceTypeCheckExpression: (value) => {
-                            switch (itemTypeof) {
-                                case "bigint":
-                                    return code `${this.reusables.snippets.isReadonlyBigIntArray}(${value})`;
-                                case "boolean":
-                                    return code `${this.reusables.snippets.isReadonlyBooleanArray}(${value})`;
-                                case "number":
-                                    return code `${this.reusables.snippets.isReadonlyNumberArray}(${value})`;
-                                case "object":
-                                    return code `${this.reusables.snippets.isReadonlyObjectArray}(${value})`;
-                                case "string":
-                                    return code `${this.reusables.snippets.isReadonlyStringArray}(${value})`;
-                                case "function":
-                                case "symbol":
-                                case "undefined":
-                                    throw new Error(`source type check on ${itemTypeof} not implemented`);
-                            }
-                        },
-                        sourceTypeName: code `readonly (${itemTypeofConversion.sourceTypeName})[]`,
-                        sourceTypeof: itemTypeofConversion.sourceTypeof,
-                    });
-                }
-            }
-        }
-        else {
-            // minCount > 0
-            // Don't try to do any item type conversions here (yet).
-            conversions.push({
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.NonEmptyList}.isNonEmpty(${value})`,
-                sourceTypeName: this.name,
-                sourceTypeof: "object",
+            sourceTypes.push({
+                name: "undefined",
+                typeof: "undefined",
             });
         }
-        return conversions;
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToArray}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes,
+        });
     }
     get equalsFunction() {
         return code `((left, right) => ${this.reusables.snippets.arrayEquals}(left, right, ${this.itemType.equalsFunction}))`;
@@ -126,21 +58,21 @@ export class AbstractCollectionType extends AbstractContainerType {
     get graphqlType() {
         return new AbstractContainerType.GraphqlType(code `new ${this.reusables.imports.GraphQLList}(${this.itemType.graphqlType.name})`, this.reusables);
     }
+    get hashFunction() {
+        return code `${this.reusables.snippets.hashArray}(${this.itemType.hashFunction})`;
+    }
     get mutable() {
         return this._mutable || this.itemType.mutable;
     }
     get name() {
-        if (this._mutable) {
-            return code `(${this.itemType.name})[]`;
-        }
-        if (this.minCount === 0n) {
-            return code `readonly (${this.itemType.name})[]`;
-        }
-        return code `${this.reusables.imports.NonEmptyList}<${this.itemType.name}>`;
+        return code `${!this._mutable ? "readonly " : ""}(${this.itemType.name})[]`;
     }
     get schemaType() {
         return code `${this.reusables.snippets.CollectionSchema}<${this.itemType.schemaType}>`;
     }
+    get validationFunction() {
+        return Maybe.of(code `${this.reusables.snippets.validateArray}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)}, ${literalOf(!this._mutable)})`);
+    }
     get schemaObject() {
         return {
             ...super.schemaObject,
@@ -149,39 +81,16 @@ export class AbstractCollectionType extends AbstractContainerType {
     }
     fromJsonExpression({ variables, }) {
         let expression = variables.value;
-        if (!this._mutable && this.minCount > 0n) {
-            expression = code `${this.reusables.imports.NonEmptyList}.fromArray(${expression}).unsafeCoerce()`;
-        }
         if (this.minCount === 0n) {
             expression = code `(${expression} ?? [])`;
         }
-        const valueVariable = code `item`;
-        const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: valueVariable },
-        });
-        return codeEquals(itemFromJsonExpression, valueVariable)
-            ? expression
-            : code `${expression}.map(item => (${itemFromJsonExpression}))`;
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.name}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    hashStatements({ depth, variables, }) {
-        return [
-            code `for (const item${depth} of ${variables.value}) { ${joinCode(this.itemType
-                .hashStatements({
-                depth: depth + 1,
-                variables: {
-                    hasher: variables.hasher,
-                    value: code `item${depth}`,
-                },
-            })
-                .concat())} }`,
-        ];
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
     jsonSchema(parameters) {
         let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
         if (this.minCount > 0n) {
@@ -195,13 +104,16 @@ export class AbstractCollectionType extends AbstractContainerType {
         }
         return schema;
     }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })}))`;
     }
 }
 __decorate([
     Memoize()
-], AbstractCollectionType.prototype, "conversions", null);
+], AbstractCollectionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "equalsFunction", null);
@@ -214,12 +126,18 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "name", null);
 __decorate([
     Memoize()
 ], AbstractCollectionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], AbstractCollectionType.prototype, "validationFunction", null);
 (function (AbstractCollectionType) {
     AbstractCollectionType.GraphqlType = AbstractContainerType.GraphqlType;
     AbstractCollectionType.isItemType = AbstractContainerType.isItemType;

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -38,13 +38,15 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
     get recursive(): boolean;
     get schema(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
+    protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
+    protected get itemValidationFunctionDefault(): Code;
     protected get schemaObject(): {
         item: Code;
         kind: Code;
     };
 }
 export declare namespace AbstractContainerType {
-    type Conversion = AbstractType.Conversion;
+    type ConversionFunction = AbstractType.ConversionFunction;
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;