@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/generators/ts/SetType.js

@@ -5,18 +5,80 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "Set";
+    minCount;
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
+    constructor({ minCount, ...superParameters }) {
+        super(superParameters);
+        this.minCount = minCount;
+        invariant(this.minCount >= 0n);
+        if (this._mutable) {
+            invariant(this.minCount === 0n);
+        }
+    }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        let conversionFunction;
+        const sourceTypes = [];
+        if (itemConversionFunction.sourceTypes.some((sourceType) => sourceType.jsType.typeof === "object" &&
+            sourceType.jsType.instanceof === "Array")) {
+            conversionFunction = this.reusables.snippets.convertToArraySet;
+        }
+        else {
+            conversionFunction = this.reusables.snippets.convertToScalarSet;
+            // Convert from a single item
+            sourceTypes.push(...itemConversionFunction.sourceTypes);
+        }
+        // Convert from an array of items
+        sourceTypes.push({
+            expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+            jsType: { instanceof: "Array", typeof: "object" },
+        });
+        // Convert from undefined to an empty array
+        if (this.minCount === 0n) {
+            sourceTypes.push({
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            });
+        }
+        return Maybe.of({
+            code: code `${conversionFunction}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes,
+        });
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
+    get schemaInitializers() {
+        let schemaInitializers = super.schemaInitializers;
+        if (this.minCount > 0n) {
+            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
+        }
+        return schemaInitializers;
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (this.minCount === 0n) {
+            expression = code `(${expression} ?? [])`;
+        }
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
         return joinCode([
@@ -25,8 +87,21 @@ export class SetType extends AbstractCollectionType {
             code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`,
         ], { on: "." });
     }
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
+        if (this.minCount > 0n) {
+            schema = code `${schema}.nonempty().min(${this.minCount})`;
+        }
+        else {
+            schema = code `${schema}.optional()`;
+        }
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
+    }
     jsonType() {
-        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;
+        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`;
         if (this.minCount === 0n) {
             return new AbstractCollectionType.JsonType(name, { optional: true });
         }
@@ -41,6 +116,9 @@ export class SetType extends AbstractCollectionType {
         return code `(${variables.value}.length > 0 ? \`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\` : undefined)`;
     }
 }
+__decorate([
+    Memoize()
+], SetType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/Snippets.d.ts

@@ -69,7 +69,7 @@ export declare class Snippets {
     get booleanEquals(): Snippet;
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
-    get convertToArray(): Snippet;
+    get convertToArraySet(): Snippet;
     get convertToBlankNode(): Snippet;
     get convertToBlankNodeIdentifierProperty(): Snippet;
     get convertToIdentifier(): Snippet;
@@ -79,8 +79,10 @@ export declare class Snippets {
     get convertToLazyObject(): Snippet;
     get convertToLazyObjectOption(): Snippet;
     get convertToLazyObjectSet(): Snippet;
+    get convertToList(): Snippet;
     get convertToLiteral(): Snippet;
     get convertToMaybe(): Snippet;
+    get convertToScalarSet(): Snippet;
     get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
     get dateSparqlWherePatterns(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -23,7 +23,7 @@ import { snippets_CollectionFilter } from "./_snippets/snippets_CollectionFilter
 import { snippets_CollectionSchema } from "./_snippets/snippets_CollectionSchema.js";
 import { snippets_ConversionFunction } from "./_snippets/snippets_ConversionFunction.js";
 import { snippets_compactRecord } from "./_snippets/snippets_compactRecord.js";
-import { snippets_convertToArray } from "./_snippets/snippets_convertToArray.js";
+import { snippets_convertToArraySet } from "./_snippets/snippets_convertToArraySet.js";
 import { snippets_convertToBlankNode } from "./_snippets/snippets_convertToBlankNode.js";
 import { snippets_convertToBlankNodeIdentifierProperty } from "./_snippets/snippets_convertToBlankNodeIdentifierProperty.js";
 import { snippets_convertToIdentifier } from "./_snippets/snippets_convertToIdentifier.js";
@@ -33,8 +33,10 @@ import { snippets_convertToIriIdentifierProperty } from "./_snippets/snippets_co
 import { snippets_convertToLazyObject } from "./_snippets/snippets_convertToLazyObject.js";
 import { snippets_convertToLazyObjectOption } from "./_snippets/snippets_convertToLazyObjectOption.js";
 import { snippets_convertToLazyObjectSet } from "./_snippets/snippets_convertToLazyObjectSet.js";
+import { snippets_convertToList } from "./_snippets/snippets_convertToList.js";
 import { snippets_convertToLiteral } from "./_snippets/snippets_convertToLiteral.js";
 import { snippets_convertToMaybe } from "./_snippets/snippets_convertToMaybe.js";
+import { snippets_convertToScalarSet } from "./_snippets/snippets_convertToScalarSet.js";
 import { snippets_convertWithDefaultValue } from "./_snippets/snippets_convertWithDefaultValue.js";
 import { snippets_DateFilter } from "./_snippets/snippets_DateFilter.js";
 import { snippets_DateSchema } from "./_snippets/snippets_DateSchema.js";
@@ -326,8 +328,8 @@ export class Snippets {
     get compactRecord() {
         return this.snippet(snippets_compactRecord);
     }
-    get convertToArray() {
-        return this.snippet(snippets_convertToArray);
+    get convertToArraySet() {
+        return this.snippet(snippets_convertToArraySet);
     }
     get convertToBlankNode() {
         return this.snippet(snippets_convertToBlankNode);
@@ -356,12 +358,18 @@ export class Snippets {
     get convertToLazyObjectSet() {
         return this.snippet(snippets_convertToLazyObjectSet);
     }
+    get convertToList() {
+        return this.snippet(snippets_convertToList);
+    }
     get convertToLiteral() {
         return this.snippet(snippets_convertToLiteral);
     }
     get convertToMaybe() {
         return this.snippet(snippets_convertToMaybe);
     }
+    get convertToScalarSet() {
+        return this.snippet(snippets_convertToScalarSet);
+    }
     get convertWithDefaultValue() {
         return this.snippet(snippets_convertWithDefaultValue);
     }
@@ -779,7 +787,7 @@ __decorate([
 ], Snippets.prototype, "compactRecord", null);
 __decorate([
     Memoize()
-], Snippets.prototype, "convertToArray", null);
+], Snippets.prototype, "convertToArraySet", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToBlankNode", null);
@@ -807,12 +815,18 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToLazyObjectSet", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToList", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToLiteral", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToMaybe", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToScalarSet", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertWithDefaultValue", null);

package/dist/generators/ts/StringType.d.ts

@@ -6,8 +6,10 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly typeof: "string";
+    }];
     readonly kind = "String";
-    readonly typeofs: "string"[];
     readonly valueSparqlWherePatternsFunction: Code;
     get expression(): Code;
     get schemaType(): Code;

package/dist/generators/ts/StringType.js

@@ -13,8 +13,12 @@ export class StringType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashString}`;
+    jsTypes = [
+        {
+            typeof: "string",
+        },
+    ];
     kind = "String";
-    typeofs = ["string"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
     get expression() {
         if (this.primitiveIn.length > 0) {

package/dist/generators/ts/TermType.d.ts

@@ -10,6 +10,10 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly schemaType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly valueSparqlWherePatternsFunction: Code;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;

package/dist/generators/ts/TermType.js

@@ -18,6 +18,9 @@ export class TermType extends AbstractTermType {
     kind = "Term";
     nodeKinds;
     schemaType = code `${this.reusables.snippets.TermSchema}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "ts-log";
-import * as ast from "../../ast/index.js";
+import type * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 import type { TsFeature } from "./TsFeature.js";
 export declare class TsGenerator implements Generator {

package/dist/generators/ts/TsGenerator.js

@@ -1,6 +1,5 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import * as ast from "../../ast/index.js";
 import { BlankNodeType } from "./BlankNodeType.js";
 import { GraphqlSchema } from "./GraphqlSchema.js";
 import { IdentifierType } from "./IdentifierType.js";
@@ -12,6 +11,9 @@ import { Reusables } from "./Reusables.js";
 import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
+function compareTsNamedType(left, right) {
+    return left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce());
+}
 export class TsGenerator {
     configuration;
     logger;
@@ -31,54 +33,77 @@ export class TsGenerator {
             reusables,
         });
         let declarations = [];
-        for (const namedObjectType of ast_.namedObjectTypes) {
-            for (const tsImport of namedObjectType.tsImports) {
-                declarations.push(code `${tsImport}`);
+        const tsNamedTypes = [];
+        const tsNamedObjectTypes = [];
+        const tsNamedObjectUnionTypes = [];
+        for (const astNamedType of ast_.namedTypes) {
+            const tsNamedType = typeFactory.createType(astNamedType);
+            tsNamedTypes.push(tsNamedType);
+            if (astNamedType.kind === "Object") {
+                for (const tsImport of astNamedType.tsImports) {
+                    declarations.push(code `${tsImport}`);
+                }
             }
-        }
-        for (const astNamedUnionType of ast_.namedUnionTypes) {
-            if (astNamedUnionType.isObjectUnionType()) {
-                continue;
+            switch (tsNamedType.kind) {
+                case "Object":
+                    tsNamedObjectTypes.push(tsNamedType);
+                    break;
+                case "ObjectUnion":
+                    tsNamedObjectUnionTypes.push(tsNamedType);
+                    break;
             }
-            declarations = declarations.concat(typeFactory.createType(astNamedUnionType).declaration.toList());
         }
-        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createObjectType(astObjectType));
-        const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
-            .filter((_) => _.isObjectUnionType())
-            .map((astObjectUnionType) => typeFactory.createObjectUnionType(astObjectUnionType));
-        for (const namedObjectType of namedObjectTypesToposorted) {
-            declarations = declarations.concat(namedObjectType.declaration.toList());
+        tsNamedTypes.sort(compareTsNamedType);
+        tsNamedObjectTypes.sort(compareTsNamedType);
+        tsNamedObjectUnionTypes.sort(compareTsNamedType);
+        for (const tsNamedType of tsNamedTypes) {
+            switch (tsNamedType.kind) {
+                case "ObjectUnion":
+                case "Union":
+                    continue; // Declare compound types last.
+            }
+            tsNamedType.declaration.ifJust((declaration) => {
+                declarations.push(declaration);
+            });
         }
-        for (const namedObjectUnionType of namedObjectUnionTypesToposorted) {
-            declarations = declarations.concat(namedObjectUnionType.declaration.toList());
+        // Declare compound types last.
+        for (const tsNamedType of tsNamedTypes) {
+            switch (tsNamedType.kind) {
+                case "ObjectUnion":
+                case "Union":
+                    break;
+                default:
+                    continue;
+            }
+            tsNamedType.declaration.ifJust((declaration) => {
+                declarations.push(declaration);
+            });
         }
-        const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce()));
-        const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce()));
-        switch (namedObjectTypesNameSorted.length) {
+        switch (tsNamedObjectTypes.length) {
             case 0:
                 break;
             case 1:
-                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].expression};`);
+                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${tsNamedObjectTypes[0].expression};`);
                 break;
             default: {
                 const uberObjectUnionType = this.synthesizeUberObjectUnionType({
                     configuration,
-                    namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+                    namedObjectTypes: tsNamedObjectTypes,
                     reusables,
                 });
                 declarations = declarations.concat(uberObjectUnionType.declaration.toList());
-                namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+                tsNamedObjectUnionTypes.push(uberObjectUnionType);
             }
         }
         declarations.push(...this.objectSetTypeDeclarations({
             configuration,
-            namedObjectTypes: namedObjectTypesNameSorted,
-            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
+            namedObjectTypes: tsNamedObjectTypes,
+            namedObjectUnionTypes: tsNamedObjectUnionTypes,
             reusables,
         }));
         if (configuration.features.has("GraphQL")) {
-            const graphqlNamedObjectTypes = namedObjectTypesNameSorted.filter((namedObjectType) => !namedObjectType.synthetic);
-            const graphqlNamedObjectUnionTypes = namedObjectUnionTypesNameSorted.filter((namedObjectUnionType) => !namedObjectUnionType.synthetic);
+            const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
+            const graphqlNamedObjectUnionTypes = tsNamedObjectUnionTypes.filter((tsNamedObjectUnionType) => !tsNamedObjectUnionType.synthetic);
             if (graphqlNamedObjectTypes.length > 0) {
                 declarations.push(new GraphqlSchema({
                     configuration,
@@ -116,7 +141,7 @@ export class TsGenerator {
      * Synthesize the $Object union.
      */
     synthesizeUberObjectUnionType({ configuration, namedObjectTypes, reusables, }) {
-        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
+        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
         invariant(filteredNamedObjectTypes.length > 0);
         const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
             for (const nodeKind of namedObjectType.identifierType.nodeKinds) {

package/dist/generators/ts/TypeFactory.js

@@ -49,38 +49,24 @@ export class TypeFactory {
                 return cachedObjectType;
             }
         }
+        const discriminantProperty = astType.name.map((name) => new ObjectType.DiscriminantProperty({
+            configuration: this.configuration,
+            logger: this.logger,
+            name: `${this.configuration.syntheticNamePrefix}type`,
+            objectType: { alias: astType.name },
+            reusables: this.reusables,
+            value: name,
+        }));
         const identifierType = this.createIdentifierType(astType.identifierType);
         const objectType = new ObjectType({
             alias: astType.name.map((name) => this.tsName(name, { synthetic: astType.synthetic })),
+            discriminantProperty,
             comment: astType.comment,
             configuration: this.configuration,
             extern: astType.extern,
             fromRdfType: astType.fromRdfType,
             identifierType,
             label: astType.label,
-            lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectType(astType)),
-            lazyDiscriminantProperty: (objectType) => {
-                // Discriminant property
-                const discriminantDescendantValues = new Set();
-                for (const descendantObjectType of objectType.descendantObjectTypes) {
-                    discriminantDescendantValues.add(descendantObjectType.discriminantValue);
-                }
-                return new ObjectType.DiscriminantProperty({
-                    configuration: this.configuration,
-                    logger: this.logger,
-                    name: `${this.configuration.syntheticNamePrefix}type`,
-                    objectType,
-                    reusables: this.reusables,
-                    type: new ObjectType.DiscriminantProperty.Type({
-                        descendantValues: [...discriminantDescendantValues].sort(),
-                        mutable: false,
-                        ownValues: [objectType.discriminantValue],
-                    }),
-                });
-            },
-            lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectType(astType)),
             lazyProperties: (objectType) => {
                 const properties = astType.properties
                     .toSorted((left, right) => {
@@ -96,7 +82,9 @@ export class TypeFactory {
                     astObjectTypeProperty: astProperty,
                     objectType,
                 }));
-                properties.splice(0, 0, objectType._discriminantProperty);
+                discriminantProperty.ifJust((discriminantProperty) => {
+                    properties.splice(0, 0, discriminantProperty);
+                });
                 properties.splice(0, 0, new ObjectType.IdentifierProperty({
                     configuration: this.configuration,
                     logger: this.logger,
@@ -297,7 +285,6 @@ export class TypeFactory {
             itemType,
             label: astType.label,
             logger: this.logger,
-            minCount: 0n,
             mutable: astType.mutable,
             reusables: this.reusables,
             toRdfTypes: astType.toRdfTypes,

package/dist/generators/ts/UnionType.d.ts

@@ -38,7 +38,7 @@ export declare class UnionType<MemberTypeT extends Type> extends AbstractType {
     get referencesObjectType(): boolean;
     get schemaType(): Code;
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get typeofs(): AbstractType["typeofs"];
+    get jsTypes(): AbstractType["jsTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get inlineEqualsFunction(): Code;
@@ -84,17 +84,14 @@ type HybridDiscriminant = {
     readonly kind: "Hybrid";
     readonly memberValues: readonly {
         readonly kind: "Extrinsic" | "Intrinsic";
-        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
     }[];
     readonly name: string;
 };
 type IntrinsicDiscriminant = {
     readonly jsonName: string;
     readonly kind: "Intrinsic";
-    readonly memberValues: readonly {
-        readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
-        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
-    }[];
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
     readonly name: string;
 };
 type TypeofDiscriminant = {