@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/TsGenerator.js

@@ -1,14 +1,14 @@
 import { GraphqlSchema } from "./GraphqlSchema.js";
 import { ObjectSetType } from "./ObjectSetType.js";
+import { Operation } from "./Operation.js";
 import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
 import { Reusables } from "./Reusables.js";
+import { Service } from "./Service.js";
 import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
+import { TsFeature } from "./TsFeature.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { UberObjectDiscriminatedUnionType } from "./UberObjectDiscriminatedUnionType.js";
-function compareTsNamedType(left, right) {
-    return left.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
-}
 export class TsGenerator {
     configuration;
     logger;
@@ -29,8 +29,9 @@ export class TsGenerator {
         });
         let declarations = [];
         const tsNamedTypes = [];
-        const tsNamedObjectTypes = [];
         const tsNamedObjectDiscriminatedUnionTypes = [];
+        const tsNamedObjectIntersectionTypes = [];
+        const tsNamedObjectTypes = [];
         for (const astNamedType of ast_.namedTypes) {
             const tsNamedType = typeFactory.createType(astNamedType);
             tsNamedTypes.push(tsNamedType);
@@ -46,6 +47,9 @@ export class TsGenerator {
                 case "ObjectDiscriminatedUnion":
                     tsNamedObjectDiscriminatedUnionTypes.push(tsNamedType);
                     break;
+                case "ObjectIntersection":
+                    tsNamedObjectIntersectionTypes.push(tsNamedType);
+                    break;
             }
         }
         tsNamedTypes.sort(compareTsNamedType);
@@ -53,8 +57,9 @@ export class TsGenerator {
         tsNamedObjectDiscriminatedUnionTypes.sort(compareTsNamedType);
         for (const tsNamedType of tsNamedTypes) {
             switch (tsNamedType.kind) {
-                case "ObjectDiscriminatedUnion":
                 case "DiscriminatedUnion":
+                case "ObjectDiscriminatedUnion":
+                case "ObjectIntersection":
                     continue; // Declare compound types last.
             }
             tsNamedType.declaration.ifJust((declaration) => {
@@ -64,8 +69,9 @@ export class TsGenerator {
         // Declare compound types last.
         for (const tsNamedType of tsNamedTypes) {
             switch (tsNamedType.kind) {
-                case "ObjectDiscriminatedUnion":
                 case "DiscriminatedUnion":
+                case "ObjectDiscriminatedUnion":
+                case "ObjectIntersection":
                     break;
                 default:
                     continue;
@@ -77,17 +83,64 @@ export class TsGenerator {
         declarations = declarations.concat(new UberObjectDiscriminatedUnionType({
             configuration,
             logger: this.logger,
-            members: tsNamedObjectTypes,
+            members: tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.extern).concat(tsNamedObjectIntersectionTypes),
             reusables,
         }).declaration.toList());
-        declarations.push(...this.objectSetTypeDeclarations({
+        declarations = declarations.concat(this.objectSetTypeDeclarations({
             configuration,
-            namedObjectTypes: tsNamedObjectTypes,
-            namedObjectDiscriminatedUnionTypes: tsNamedObjectDiscriminatedUnionTypes,
+            namedObjectTypes: [
+                ...tsNamedObjectDiscriminatedUnionTypes,
+                ...tsNamedObjectIntersectionTypes,
+                ...tsNamedObjectTypes,
+            ],
             reusables,
         }));
+        declarations = declarations.concat(this.serviceDeclarations({
+            configuration,
+            services: ast_.services.map((astService) => new Service({
+                configuration,
+                comment: astService.comment,
+                label: astService.label,
+                logger: this.logger,
+                name: astService.name,
+                operations: astService.operations.map((astOperation) => {
+                    const operation = new Operation({
+                        configuration,
+                        comment: astOperation.comment,
+                        error: astOperation.error.map((astType) => {
+                            switch (astType.kind) {
+                                case "DiscriminatedUnion":
+                                    return typeFactory.createObjectDiscriminatedUnionType(astType);
+                                case "Struct":
+                                    return typeFactory.createObjectType(astType);
+                                default:
+                                    astType;
+                                    throw new Error("should never reach this point");
+                            }
+                        }),
+                        label: astOperation.label,
+                        lazyBindings: () => astOperation.bindings.map((astBinding) => new Operation.HttpBinding({
+                            errorResponses: astBinding.errorResponses,
+                            operation,
+                            request: astBinding.request,
+                            resultResponse: astBinding.resultResponse,
+                            reusables,
+                        })),
+                        logger: this.logger,
+                        name: astOperation.name,
+                        parameter: astOperation.parameter.map((astType) => typeFactory.createObjectType(astType)),
+                        result: astOperation.result.map((astType) => typeFactory.createType(astType)),
+                        reusables,
+                        service: { name: astService.name },
+                    });
+                    return operation;
+                }),
+                reusables,
+            })),
+        }));
         if (configuration.features.has("GraphQL")) {
-            const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
+            const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => tsNamedObjectType.identifierProperty.isJust() &&
+                !tsNamedObjectType.synthetic);
             const graphqlNamedObjectDiscriminatedUnionTypes = tsNamedObjectDiscriminatedUnionTypes;
             if (graphqlNamedObjectTypes.length > 0) {
                 declarations.push(new GraphqlSchema({
@@ -100,14 +153,25 @@ export class TsGenerator {
             }
         }
         declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
-        return joinCode(declarations).toString({});
+        return joinCode(declarations, { on: "\n\n" }).toString({});
     }
-    objectSetTypeDeclarations({ configuration, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }) {
+    objectSetTypeDeclarations({ configuration, namedObjectTypes, reusables, }) {
         const constructorParameters = {
             configuration,
             logger: this.logger,
-            namedObjectTypes: namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic),
-            namedObjectDiscriminatedUnionTypes,
+            namedObjectTypes: namedObjectTypes.filter((namedObjectType) => {
+                if (namedObjectType.identifierProperty.isNothing()) {
+                    return false;
+                }
+                if (namedObjectType.name.isNothing()) {
+                    return false;
+                }
+                if (namedObjectType.kind === "Object" &&
+                    (namedObjectType.extern || namedObjectType.synthetic)) {
+                    return false;
+                }
+                return true;
+            }),
             reusables,
         };
         const declarations = [];
@@ -122,6 +186,24 @@ export class TsGenerator {
         }
         return declarations;
     }
+    serviceDeclarations({ configuration, services, }) {
+        return services.flatMap((service) => {
+            const declarations = [];
+            if (configuration.features.has("Service")) {
+                declarations.push(service.interfaceDeclaration);
+            }
+            if (configuration.features.has("LoggingService")) {
+                declarations.push(service.loggingClassDeclaration);
+            }
+            if (configuration.features.has("ServiceHttpApi")) {
+                declarations.push(service.httpApiFactoryFunction);
+            }
+            return declarations;
+        });
+    }
+}
+function compareTsNamedType(left, right) {
+    return left.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
 }
 (function (TsGenerator) {
     let Configuration;
@@ -140,47 +222,9 @@ export class TsGenerator {
             },
             syntheticNamePrefix: "$",
         };
-        const featureDependenciesStatic = {
-            GraphQL: ["ObjectSet"],
-            // Alias for other features, not dependencies per se
-            JSON: ["Object.JSON"],
-            "Object.create": ["Object.schema", "Object.toString", "Object.type"],
-            "Object.equals": ["Object.type"],
-            "Object.filter": ["Object.type"],
-            "Object.fromJson": ["Object.create", "Object.JSON.type", "Object.type"],
-            "Object.fromRdf": ["Object.create", "Object.schema"],
-            "Object.hash": [],
-            // Alias for other features, not dependencies per se
-            "Object.JSON": [
-                "Object.fromJson",
-                "Object.JSON.parse",
-                "Object.JSON.schema",
-                "Object.JSON.type",
-                "Object.JSON.uiSchema",
-                "Object.toJson",
-            ],
-            "Object.JSON.parse": ["Object.JSON.schema", "Object.JSON.type"],
-            "Object.JSON.type": [],
-            "Object.JSON.schema": ["Object.JSON.type"],
-            "Object.JSON.uiSchema": [],
-            // Alias for other features, not dependencies per se
-            "Object.RDF": ["Object.fromRdf", "Object.toRdf"],
-            "Object.schema": [],
-            "Object.toJson": ["Object.JSON.type", "Object.type"],
-            "Object.toRdf": ["Object.schema", "Object.type"],
-            "Object.toString": ["Object.type"],
-            "Object.SPARQL": ["Object.schema"],
-            "Object.type": [], // Implies Object.Identifier
-            ObjectSet: ["Object.filter"],
-            // Alias for other features, not dependencies per se
-            RDF: ["Object.RDF", "RdfjsDatasetObjectSet"],
-            RdfjsDatasetObjectSet: ["Object.fromRdf", "ObjectSet"],
-            SPARQL: ["Object.SPARQL", "SparqlObjectSet"],
-            SparqlObjectSet: ["Object.SPARQL", "ObjectSet"],
-        };
         function finalize(ast, partialConfiguration) {
             const requestedFeatures = partialConfiguration?.features ?? Configuration.default_.features;
-            const featureDependencies = Object.fromEntries(Object.entries(featureDependenciesStatic).map(([k, v]) => [k, [...v]]));
+            const featureDependencies = Object.fromEntries(Object.entries(TsFeature.dependencies).map(([k, v]) => [k, [...v]]));
             if (ast.lazyTypesCount > 0) {
                 featureDependencies["Object.fromJson"].push("ObjectSet");
                 featureDependencies["Object.fromRdf"].push("ObjectSet", "RdfjsDatasetObjectSet");

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

@@ -17,10 +17,11 @@ import type { LazyType } from "./LazyType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
-export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
+export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | DiscriminatedUnionType | FloatType | IdentifierType | IntType | IriType | LangStringType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
 //# sourceMappingURL=Type.d.ts.map

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

@@ -3,28 +3,31 @@ import type { Logger } from "@rdfx/logger";
 import * as ast from "../../ast/index.js";
 import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import { ObjectType } from "./ObjectType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
     private readonly configuration;
+    private readonly constructorParameters;
+    private readonly jsonTypeFactory;
     private readonly logger;
-    private readonly reusables;
-    private cachedObjectDiscriminatedUnionTypesByShapeIdentifier;
-    private cachedObjectTypePropertiesByShapeIdentifier;
-    private cachedObjectTypesByShapeIdentifier;
+    private cachedObjectTypeShaclPropertiesByShapeIdentifier;
+    private cachedTypesByShapeIdentifier;
     constructor({ configuration, logger, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
         reusables: Reusables;
     });
-    createObjectType(astType: ast.StructType): ObjectType;
+    createDiscriminatedUnionType(astType: ast.DiscriminatedUnionType): DiscriminatedUnionType | ObjectDiscriminatedUnionType;
+    createIntersectionType(astType: ast.IntersectionType): ObjectIntersectionType;
     createObjectDiscriminatedUnionType(astType: ast.StructDiscriminatedUnionType): ObjectDiscriminatedUnionType;
+    createObjectIntersectionType(astType: ast.StructIntersectionType): ObjectIntersectionType;
+    createObjectType(astType: ast.StructType): ObjectType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
-    createDiscriminatedUnionType(astType: ast.DiscriminatedUnionType): DiscriminatedUnionType | ObjectDiscriminatedUnionType;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;
@@ -34,7 +37,7 @@ export declare class TypeFactory {
     private createLazyType;
     private createListType;
     private createLiteralType;
-    private createObjectTypeProperty;
+    private createObjectTypeShaclProperty;
     private createOptionType;
     private createSetType;
     private createTermType;