@shaclmate/compiler 4.0.40 → 4.0.42

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

@@ -6,16 +6,22 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractTermType {
     readonly conversionFunction: Maybe<AbstractTermType.ConversionFunction>;
     readonly filterFunction: Code;
-    readonly filterType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
-    readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });
-    get expression(): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    get filterType(): Code;
     get graphqlType(): AbstractTermType.GraphqlType;
+    get schemaType(): Code;
+    protected get inlineExpression(): Code;
+    protected get schemaInitializers(): Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;

package/dist/generators/ts/TermType.js

@@ -10,14 +10,15 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class TermType extends AbstractTermType {
     conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterTerm}`;
-    filterType = code `${this.reusables.snippets.TermFilter}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     kind = "Term";
     nodeKinds;
-    schemaType = code `${this.reusables.snippets.TermSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
@@ -25,7 +26,19 @@ export class TermType extends AbstractTermType {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get expression() {
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.termFromRdfResourceValues}<${this.expression}>`;
+    }
+    get filterType() {
+        return code `${this.reusables.snippets.TermFilter}<${this.expression}>`;
+    }
+    get graphqlType() {
+        throw new Error("not implemented");
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.TermSchema}<${this.expression}>`;
+    }
+    get inlineExpression() {
         return code `(${joinCode([...this.nodeKinds]
             .map((nodeKind) => {
             switch (nodeKind) {
@@ -42,8 +55,8 @@ export class TermType extends AbstractTermType {
         })
             .map((import_) => code `${import_}`), { on: " | " })})`;
     }
-    get graphqlType() {
-        throw new Error("not implemented");
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `types: ${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))}`);
     }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${[
@@ -114,7 +127,16 @@ export class TermType extends AbstractTermType {
 }
 __decorate([
     Memoize()
-], TermType.prototype, "expression", null);
+], TermType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], TermType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "jsonType", null);

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,6 @@
+import dataFactory from "@rdfx/data-factory";
 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 +12,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.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
+}
 export class TsGenerator {
     configuration;
     logger;
@@ -31,54 +34,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 === "Struct") {
+                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 +142,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) {
@@ -127,29 +153,31 @@ export class TsGenerator {
         let identifierType;
         if (nodeKinds.size === 2) {
             identifierType = new IdentifierType({
-                alias: Maybe.empty(),
+                name: Maybe.empty(),
                 comment: Maybe.empty(),
                 configuration,
                 label: Maybe.empty(),
                 logger: this.logger,
                 reusables,
+                shapeIdentifier: dataFactory.blankNode(),
             });
         }
         else {
             switch ([...nodeKinds][0]) {
                 case "BlankNode":
                     identifierType = new BlankNodeType({
-                        alias: Maybe.empty(),
+                        name: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         label: Maybe.empty(),
                         logger: this.logger,
                         reusables,
+                        shapeIdentifier: dataFactory.blankNode(),
                     });
                     break;
                 case "IRI":
                     identifierType = new IriType({
-                        alias: Maybe.empty(),
+                        name: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         hasValues: [],
@@ -157,12 +185,13 @@ export class TsGenerator {
                         label: Maybe.empty(),
                         logger: this.logger,
                         reusables,
+                        shapeIdentifier: dataFactory.blankNode(),
                     });
                     break;
             }
         }
         return new ObjectUnionType({
-            alias: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
+            name: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
             comment: Maybe.empty(),
             configuration,
             identifierType: Maybe.of(identifierType),
@@ -174,6 +203,7 @@ export class TsGenerator {
             })),
             recursive: false,
             reusables,
+            shapeIdentifier: dataFactory.blankNode(),
             synthetic: true,
         });
     }

package/dist/generators/ts/Type.d.ts

@@ -9,9 +9,9 @@ import type { FloatType } from "./FloatType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntType } from "./IntType.js";
 import type { IriType } from "./IriType.js";
-import type { LazyObjectOptionType } from "./LazyObjectOptionType.js";
-import type { LazyObjectSetType } from "./LazyObjectSetType.js";
-import type { LazyObjectType } from "./LazyObjectType.js";
+import type { LazyOptionType } from "./LazyOptionType.js";
+import type { LazySetType } from "./LazySetType.js";
+import type { LazyType } from "./LazyType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectType } from "./ObjectType.js";
@@ -21,5 +21,5 @@ import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
+export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -19,8 +19,8 @@ export declare class TypeFactory {
         logger: Logger;
         reusables: Reusables;
     });
-    createObjectType(astType: ast.ObjectType): ObjectType;
-    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
+    createObjectType(astType: ast.StructType): ObjectType;
+    createObjectUnionType(astType: ast.StructUnionType): ObjectUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
@@ -29,9 +29,9 @@ export declare class TypeFactory {
     private createDefaultValueType;
     private createIdentifierType;
     private createIriType;
-    private createLazyObjectOptionType;
-    private createLazyObjectSetType;
-    private createLazyObjectType;
+    private createLazyOptionType;
+    private createLazySetType;
+    private createLazyType;
     private createListType;
     private createLiteralType;
     private createObjectTypeProperty;