@shaclmate/compiler 3.0.2 → 3.0.4

package/dist/_ShapesGraphToAstTransformer/flattenAstObjectCompositeTypeMemberTypes.d.ts

@@ -1,6 +1,6 @@
-import type { TsFeature } from "enums/TsFeature.js";
 import { Either } from "purify-ts";
 import type * as ast from "../ast/index.js";
+import type { TsFeature } from "../enums/TsFeature.js";
 import type * as input from "../input/index.js";
 export declare function flattenAstObjectCompositeTypeMemberTypes({ objectCompositeTypeKind, memberTypes, shape, }: {
     objectCompositeTypeKind: "ObjectIntersectionType" | "ObjectUnionType";

package/dist/ast/ObjectCompositeType.d.ts

@@ -1,5 +1,5 @@
-import type { TsFeature } from "enums/TsFeature.js";
 import type { Maybe } from "purify-ts";
+import type { TsFeature } from "../enums/TsFeature.js";
 import type { CompositeType } from "./CompositeType.js";
 import type { Name } from "./Name.js";
 import type { ObjectType } from "./ObjectType.js";

package/dist/generators/ts/BooleanType.js

@@ -61,10 +61,10 @@ export class BooleanType extends PrimitiveType {
             .map((defaultValue) => {
             if (defaultValue) {
                 // If the default is true, only serialize the value if it's false
-                return `!${variables.value} ? false : undefined`;
+                return `(!${variables.value} ? [false] : [])`;
             }
             // If the default is false, only serialize the value if it's true
-            return `${variables.value} ? true : undefined`;
+            return `(${variables.value} ? [true] : [])`;
         })
             .orDefault(variables.value);
     }

package/dist/generators/ts/DateTimeType.js

@@ -80,8 +80,8 @@ export class DateTimeType extends PrimitiveType {
     toRdfExpression({ variables, }) {
         const valueToRdf = `rdfLiteral.toRdf(${variables.value}, ${objectInitializer({ dataFactory: "dataFactory", datatype: rdfjsTermExpression(this.xsdDatatype) })})`;
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${valueToRdf} : undefined`)
-            .orDefault(valueToRdf);
+            .map((defaultValue) => `(${variables.value}.getTime() !== ${defaultValue.getTime()} ? [${valueToRdf}] : [])`)
+            .orDefault(`[${valueToRdf}]`);
     }
 }
 __decorate([

package/dist/generators/ts/Import.js

@@ -6,64 +6,60 @@ export var Import;
 (function (Import) {
     Import.DATA_FACTORY = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["dataFactory"],
-    };
-    Import.DATASET_FACTORY = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["datasetFactory"],
+        moduleSpecifier: "n3",
+        namedImports: [{ alias: "dataFactory", name: "DataFactory" }],
     };
+    Import.DATASET_FACTORY = "import { StoreFactory as _DatasetFactory } from 'n3'; const datasetFactory = new _DatasetFactory();";
     Import.GRAPHQL = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["graphql"],
+        moduleSpecifier: "graphql",
+        namespaceImport: "graphql",
     };
     Import.GRAPHQL_SCALARS = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["graphqlScalars"],
+        moduleSpecifier: "graphql-scalars",
+        namespaceImport: "graphqlScalars",
     };
     Import.PURIFY = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["purify"],
+        moduleSpecifier: "purify-ts",
+        namespaceImport: "purify",
     };
     Import.RDF_LITERAL = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["rdfLiteral"],
+        moduleSpecifier: "rdf-literal",
+        namespaceImport: "rdfLiteral",
     };
     Import.RDFJS_RESOURCE = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["rdfjsResource"],
+        moduleSpecifier: "rdfjs-resource",
+        namespaceImport: "rdfjsResource",
     };
     Import.RDFJS_TYPES = {
         isTypeOnly: true,
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["rdfjs"],
+        moduleSpecifier: "@rdfjs/types",
+        namespaceImport: "rdfjs",
     };
     Import.SHA256 = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
+        moduleSpecifier: "js-sha256",
         namedImports: ["sha256"],
     };
     Import.SPARQLJS = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["sparqljs"],
+        moduleSpecifier: "sparqljs",
+        namespaceImport: "sparqljs",
     };
     Import.UUID = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["uuid"],
+        moduleSpecifier: "uuid",
+        namespaceImport: "uuid",
     };
     Import.ZOD = {
         kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "@shaclmate/runtime",
-        namedImports: ["zod"],
+        moduleSpecifier: "zod",
+        namedImports: [{ alias: "zod", name: "z" }],
     };
 })(Import || (Import = {}));
 //# sourceMappingURL=Import.js.map

package/dist/generators/ts/ListType.js

@@ -289,7 +289,7 @@ export class ListType extends Type {
                 break;
             }
         }
-        return `${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        return `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
@@ -302,7 +302,7 @@ export class ListType extends Type {
     
     ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
         
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ...${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
 
     if (itemIndex + 1 === list.length) {
       currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)});
@@ -319,7 +319,7 @@ export class ListType extends Type {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}`;
+).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}]`;
     }
     useImports(parameters) {
         const imports = this.itemType.useImports(parameters).concat();

package/dist/generators/ts/NumberType.js

@@ -58,8 +58,8 @@ export class NumberType extends PrimitiveType {
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value} !== ${defaultValue} ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `(${variables.value} !== ${defaultValue} ? [${variables.value}] : [])`)
+            .orDefault(`[${variables.value}]`);
     }
 }
 __decorate([

package/dist/generators/ts/ObjectType.js

@@ -322,9 +322,9 @@ export class ObjectType extends DeclaredType {
     toRdfExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return `${variables.value}.${syntheticNamePrefix}toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
+                return `[${variables.value}.${syntheticNamePrefix}toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier]`;
             case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
+                return `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier]`;
         }
     }
     useImports() {

package/dist/generators/ts/ObjectUnionType.js

@@ -621,9 +621,9 @@ return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right
         const options = `{ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }`;
         switch (this.memberTypes[0].declarationType) {
             case "class":
-                return `${variables.value}.${syntheticNamePrefix}toRdf(${options})`;
+                return `[${variables.value}.${syntheticNamePrefix}toRdf(${options}).identifier]`;
             case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${options})`;
+                return `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${options}).identifier]`;
         }
     }
     useImports() {

package/dist/generators/ts/OptionType.js

@@ -137,10 +137,11 @@ export class OptionType extends Type {
         const itemTypeToRdfExpression = this.itemType.toRdfExpression({
             variables: { ...variables, value: "value" },
         });
-        if (itemTypeToRdfExpression === "value") {
-            return variables.value;
+        let toRdfExpression = `${variables.value}.toList()`;
+        if (itemTypeToRdfExpression !== "[value]") {
+            toRdfExpression = `${toRdfExpression}.flatMap((value) => ${itemTypeToRdfExpression})`;
         }
-        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+        return toRdfExpression;
     }
     useImports(parameters) {
         return [...this.itemType.useImports(parameters), Import.PURIFY];

package/dist/generators/ts/SetType.js

@@ -166,7 +166,7 @@ export class SetType extends Type {
         return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
     }
     toRdfExpression({ variables, }) {
-        return `${variables.value}.map((item) => ${this.itemType.toRdfExpression({
+        return `${variables.value}.flatMap((item) => ${this.itemType.toRdfExpression({
             variables: { ...variables, value: "item" },
         })})`;
     }

package/dist/generators/ts/StringType.js

@@ -67,8 +67,8 @@ export class StringType extends PrimitiveType {
     }
     toRdfExpression({ variables, }) {
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value} !== "${defaultValue}" ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `(${variables.value} !== "${defaultValue}" ? [${variables.value}] : [])`)
+            .orDefault(`[${variables.value}]`);
     }
 }
 __decorate([

package/dist/generators/ts/TermType.js

@@ -252,8 +252,8 @@ export class TermType extends Type {
     }
     toRdfExpression({ variables, }) {
         return this.defaultValue
-            .map((defaultValue) => `!${variables.value}.equals(${rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `(!${variables.value}.equals(${rdfjsTermExpression(defaultValue)}) ? [${variables.value}] : [])`)
+            .orDefault(`[${variables.value}]`);
     }
     useImports() {
         const imports = [Import.RDFJS_TYPES];

package/dist/generators/ts/TsGenerator.js

@@ -1,4 +1,3 @@
-import { invariant } from "ts-invariant";
 import { Project, } from "ts-morph";
 import * as ast from "../../ast/index.js";
 import { Import } from "./Import.js";
@@ -40,32 +39,17 @@ export class TsGenerator {
         }
         // Deduplicate and add imports
         const stringImports = new Set();
-        const structureImports = [];
+        const structureImportsByModuleSpecifier = {};
         for (const import_ of imports) {
             if (typeof import_ === "string") {
                 stringImports.add(import_);
-                continue;
             }
-            const importWithSameModuleSpecifier = structureImports.find((structureImport) => structureImport.moduleSpecifier === import_.moduleSpecifier);
-            if (!importWithSameModuleSpecifier) {
-                structureImports.push(import_);
-                continue;
-            }
-            // Merge named imports
-            invariant(!import_.namespaceImport);
-            invariant(Array.isArray(import_.namedImports) &&
-                import_.namedImports.every((value) => typeof value === "string"));
-            invariant(!importWithSameModuleSpecifier.namespaceImport);
-            invariant(Array.isArray(importWithSameModuleSpecifier.namedImports) &&
-                importWithSameModuleSpecifier.namedImports.every((value) => typeof value === "string"));
-            for (const newNamedImport of import_.namedImports) {
-                if (!importWithSameModuleSpecifier.namedImports.includes(newNamedImport)) {
-                    importWithSameModuleSpecifier.namedImports.push(newNamedImport);
-                }
+            else {
+                structureImportsByModuleSpecifier[import_.moduleSpecifier] = import_;
             }
         }
         sourceFile.addStatements([...stringImports]);
-        sourceFile.addStatements(structureImports);
+        sourceFile.addStatements(Object.values(structureImportsByModuleSpecifier));
         // Deduplicate and add snippet declarations
         const addedSnippetDeclarations = new Set();
         for (const declaredType of declaredTypes) {

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

@@ -184,8 +184,8 @@ export declare abstract class Type {
         };
     }): string;
     /**
-     * An expression that converts a property value of this type to one that that can be .add'd to
-     * an rdfjsResource.Resource.
+     * An expression that converts a property value of this type to an array of values that can be .add'd to a rdfjsResource.MutableResource
+     * (BlankNode | Literal | NamedNode | boolean | number | string)[].
      */
     abstract toRdfExpression(parameters: {
         variables: {

package/dist/generators/ts/UnionType.js

@@ -374,12 +374,12 @@ ${this.memberTypes
     }
     toRdfExpression({ variables, }) {
         return this.ternaryExpression({
-            memberTypeExpression: (memberType) => memberType.toRdfExpression({
+            memberTypeExpression: (memberType) => `(${memberType.toRdfExpression({
                 variables: {
                     ...variables,
                     value: memberType.payload(variables.value),
                 },
-            }),
+            })} as readonly Parameters<rdfjsResource.MutableResource["add"]>[1][])`,
             variables,
         });
     }
@@ -400,9 +400,13 @@ ${this.memberTypes
             if (expression.length === 0) {
                 return memberTypeExpression(memberType);
             }
+            const memberTypeExpression_ = memberTypeExpression(memberType);
+            if (memberTypeExpression_ === expression) {
+                return expression;
+            }
             return `(${memberType.discriminatorValues
                 .map((value) => `${this.discriminatorVariable(variables.value)} === "${value}"`)
-                .join(" || ")}) ? ${memberTypeExpression(memberType)} : ${expression}`;
+                .join(" || ")}) ? ${memberTypeExpression_} : ${expression}`;
         }, "");
     }
 }

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -183,7 +183,7 @@ export class ShaclProperty extends Property {
     }
     toRdfStatements({ variables, }) {
         return [
-            `${variables.resource}.add(${this.predicate}, ${this.type.toRdfExpression({
+            `${variables.resource}.add(${this.predicate}, ...${this.type.toRdfExpression({
                 variables: { ...variables, predicate: this.predicate },
             })});`,
         ];

package/dist/generators/ts/_ObjectType/rdfFunctionDeclarations.js

@@ -71,6 +71,12 @@ function propertiesFromRdfFunctionDeclaration() {
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
         const predicate = rdfjsTermExpression(rdf.type);
+        // Check the expected type and its known subtypes
+        const cases = new Set();
+        cases.add(fromRdfType.value);
+        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
+            cases.add(descendantFromRdfType.value);
+        }
         statements.push(`\
 if (!${variables.ignoreRdfType}) {
   const ${syntheticNamePrefix}rdfTypeCheck: purify.Either<Error, true> = ${variables.resource}.value(${predicate})
@@ -78,7 +84,7 @@ if (!${variables.ignoreRdfType}) {
     .chain((actualRdfType) => {
       // Check the expected type and its known subtypes
       switch (actualRdfType.value) {
-        ${[`case "${fromRdfType.value}":`].concat(this.descendantFromRdfTypes.map((descendantFromRdfType) => `case "${descendantFromRdfType.value}":`)).join("\n")}
+        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
           return purify.Either.of(true);
       }
 

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -1,7 +1,7 @@
 import { StructureKind } from "ts-morph";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
-    return Object.entries(objectSetMethodSignatures({ objectType })).map(([methodName, methodSignature]) => ({
+    return Object.values(objectSetMethodSignatures({ objectType })).map((methodSignature) => ({
         ...methodSignature,
         kind: StructureKind.Method,
         parameters: methodSignature.parameters
@@ -11,9 +11,9 @@ export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
             }))
             : methodSignature.parameters,
         isAsync: true,
-        statements: methodName === "objects"
-            ? [`return [purify.Left(new Error("${methodName}: not supported"))];`]
-            : [`return purify.Left(new Error("${methodName}: not supported"));`],
+        statements: [
+            `return purify.Left(new Error("${methodSignature.name}: not supported")) satisfies Awaited<${methodSignature.returnType}>;`,
+        ],
     }));
 }
 //# sourceMappingURL=unsupportedObjectSetMethodDeclarations.js.map