@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/IdentifierType.d.ts

@@ -1,15 +1,25 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { type FunctionDeclarationStructure, type VariableStatementStructure } from "ts-morph";
 import { TermType } from "./TermType.js";
-import type { Type } from "./Type.js";
-export declare class IdentifierType extends TermType<BlankNode | NamedNode> {
+import { Type } from "./Type.js";
+export declare class IdentifierType extends TermType<NamedNode, BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
     get conversions(): readonly Type.Conversion[];
+    get fromStringFunctionDeclaration(): FunctionDeclarationStructure;
+    get graphqlName(): Type.GraphqlName;
     get isNamedNodeKind(): boolean;
-    get jsonName(): string;
+    get jsonName(): Type.JsonName;
     get name(): string;
-    fromJsonExpression({ variables, }: Parameters<TermType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): string;
-    jsonZodSchema({ variables, }: Parameters<TermType<BlankNode | NamedNode>["jsonZodSchema"]>[0]): ReturnType<TermType<BlankNode | NamedNode>["jsonZodSchema"]>;
-    toJsonExpression({ variables, }: Parameters<TermType<BlankNode | NamedNode>["toJsonExpression"]>[0]): string;
-    protected propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<BlankNode | NamedNode>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    get toStringFunctionDeclaration(): VariableStatementStructure;
+    fromJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): string;
+    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
+        defaultValue?: string;
+        hasValues?: string;
+        languageIn?: string;
+        valueTo?: string;
+    };
+    graphqlResolveExpression({ variables: { value }, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
+    jsonZodSchema({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>[0]): ReturnType<TermType<NamedNode, BlankNode | NamedNode>["jsonZodSchema"]>;
+    toJsonExpression({ variables, }: Parameters<TermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): string;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/generators/ts/IdentifierType.js

@@ -4,14 +4,16 @@ 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 { StructureKind, VariableDeclarationKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
+import { Type } from "./Type.js";
 export class IdentifierType extends TermType {
     kind = "IdentifierType";
     get conversions() {
         return super.conversions.concat([
             {
-                conversionExpression: (value) => `${this.dataFactoryVariable}.namedNode(${value})`,
+                conversionExpression: (value) => `dataFactory.namedNode(${value})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
                 sourceTypeName: this.in_.length > 0
                     ? this.in_.map((iri) => `"${iri.value}"`).join(" | ")
@@ -19,6 +21,55 @@ export class IdentifierType extends TermType {
             },
         ]);
     }
+    get fromStringFunctionDeclaration() {
+        if (this.nodeKinds.has("BlankNode") &&
+            this.nodeKinds.has("NamedNode") &&
+            this.in_.length === 0) {
+            // Wrap rdfjsResource.Resource.Identifier.fromString
+            return {
+                isExported: true,
+                kind: StructureKind.Function,
+                name: "fromString",
+                parameters: [
+                    {
+                        name: "identifier",
+                        type: "string",
+                    },
+                ],
+                returnType: "purify.Either<Error, rdfjsResource.Resource.Identifier>",
+                statements: [
+                    "return purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({ dataFactory, identifier }));",
+                ],
+            };
+        }
+        const expressions = [
+            "purify.Either.encase(() => rdfjsResource.Resource.Identifier.fromString({ dataFactory, identifier }))",
+        ];
+        if (this.isNamedNodeKind) {
+            expressions.push(`chain((identifier) => (identifier.termType === "NamedNode") ? purify.Either.of(identifier) : purify.Left(new Error("expected identifier to be NamedNode")))`);
+            if (this.in_.length > 0) {
+                expressions.push(`chain((identifier) => { switch (identifier.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of(identifier as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`);
+            }
+        }
+        return {
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromString",
+            parameters: [
+                {
+                    name: "identifier",
+                    type: "string",
+                },
+            ],
+            returnType: `purify.Either<Error, ${this.name}>`,
+            statements: [
+                `return ${expressions.join(".")} as purify.Either<Error, ${this.name}>;`,
+            ],
+        };
+    }
+    get graphqlName() {
+        return new Type.GraphqlName("graphql.GraphQLString");
+    }
     get isNamedNodeKind() {
         return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");
     }
@@ -26,9 +77,9 @@ export class IdentifierType extends TermType {
         if (this.in_.length > 0 && this.isNamedNodeKind) {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")} }`;
+            return new Type.JsonName(`{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")} }`);
         }
-        return `{ readonly "@id": string }`;
+        return new Type.JsonName(`{ readonly "@id": string }`);
     }
     get name() {
         if (this.in_.length > 0 && this.isNamedNodeKind) {
@@ -42,9 +93,24 @@ export class IdentifierType extends TermType {
             .map((nodeKind) => `rdfjs.${nodeKind}`)
             .join(" | ")})`;
     }
+    get toStringFunctionDeclaration() {
+        // Re-export rdfjsResource.Resource.Identifier.toString
+        return {
+            declarationKind: VariableDeclarationKind.Const,
+            isExported: true,
+            kind: StructureKind.VariableStatement,
+            declarations: [
+                {
+                    initializer: "rdfjsResource.Resource.Identifier.toString",
+                    leadingTrivia: "// biome-ignore lint/suspicious/noShadowRestrictedNames:",
+                    name: "toString",
+                },
+            ],
+        };
+    }
     fromJsonExpression({ variables, }) {
-        const valueToBlankNode = `${this.dataFactoryVariable}.blankNode(${variables.value}["@id"].substring(2))`;
-        const valueToNamedNode = `${this.dataFactoryVariable}.namedNode(${variables.value}["@id"])`;
+        const valueToBlankNode = `dataFactory.blankNode(${variables.value}["@id"].substring(2))`;
+        const valueToNamedNode = `dataFactory.namedNode(${variables.value}["@id"])`;
         if (this.nodeKinds.size === 2) {
             return `(${variables.value}["@id"].startsWith("_:") ? ${valueToBlankNode} : ${valueToNamedNode})`;
         }
@@ -55,6 +121,29 @@ export class IdentifierType extends TermType {
                 return valueToNamedNode;
         }
     }
+    fromRdfExpressionChain({ variables, }) {
+        let valueToExpression;
+        if (this.nodeKinds.size === 2) {
+            valueToExpression = "value.toIdentifier()";
+        }
+        else if (this.isNamedNodeKind) {
+            valueToExpression = "value.toIri()";
+            if (this.in_.length > 0) {
+                const eitherTypeParameters = `<Error, ${this.name}>`;
+                valueToExpression = `${valueToExpression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of${eitherTypeParameters}(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
+            }
+        }
+        else {
+            throw new Error("not implemented");
+        }
+        return {
+            ...super.fromRdfExpressionChain,
+            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
+        };
+    }
+    graphqlResolveExpression({ variables: { value }, }) {
+        return `rdfjsResource.Resource.Identifier.toString(${value})`;
+    }
     jsonZodSchema({ variables, }) {
         let idSchema;
         if (this.in_.length > 0 && this.isNamedNodeKind) {
@@ -80,21 +169,26 @@ export class IdentifierType extends TermType {
                 return valueToNamedNode;
         }
     }
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        if (this.nodeKinds.size === 2) {
-            return `${variables.resourceValue}.toIdentifier()`;
-        }
-        if (this.isNamedNodeKind) {
-            let expression = `${variables.resourceValue}.toIri()`;
-            if (this.in_.length > 0) {
-                expression = `${expression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of<rdfjsResource.Resource.ValueError, ${this.name}>(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
-            }
-            return expression;
-        }
-        throw new Error(`not implemented: ${this.name}`);
-    }
 }
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "fromStringFunctionDeclaration", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "graphqlName", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "isNamedNodeKind", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], IdentifierType.prototype, "name", null);
+__decorate([
+    Memoize()
+], IdentifierType.prototype, "toStringFunctionDeclaration", null);
 //# sourceMappingURL=IdentifierType.js.map

package/dist/generators/ts/Import.d.ts

@@ -4,6 +4,8 @@ export type Import = ImportDeclarationStructure | string;
  * Singleton values for common imports.
  */
 export declare namespace Import {
+    const GRAPHQL: Import;
+    const GRAPHQL_SCALARS: Import;
     const PURIFY: Import;
     const RDF_LITERAL: Import;
     const RDFJS_RESOURCE: Import;

package/dist/generators/ts/Import.js

@@ -4,6 +4,16 @@ import { StructureKind } from "ts-morph";
  */
 export var Import;
 (function (Import) {
+    Import.GRAPHQL = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "graphql",
+        namespaceImport: "graphql",
+    };
+    Import.GRAPHQL_SCALARS = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "graphql-scalars",
+        namespaceImport: "graphqlScalars",
+    };
     Import.PURIFY = {
         kind: StructureKind.ImportDeclaration,
         moduleSpecifier: "purify-ts",

package/dist/generators/ts/IntType.d.ts

@@ -0,0 +1,6 @@
+import { NumberType } from "./NumberType.js";
+import { Type } from "./Type.js";
+export declare class IntType extends NumberType {
+    get graphqlName(): Type.GraphqlName;
+}
+//# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { Memoize } from "typescript-memoize";
+import { NumberType } from "./NumberType.js";
+import { Type } from "./Type.js";
+export class IntType extends NumberType {
+    get graphqlName() {
+        return new Type.GraphqlName("graphql.GraphQLInt");
+    }
+}
+__decorate([
+    Memoize()
+], IntType.prototype, "graphqlName", null);
+//# sourceMappingURL=IntType.js.map

package/dist/generators/ts/ListType.d.ts

@@ -1,38 +1,41 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy, TsFeature } from "../../enums/index.js";
+import type { IdentifierMintingStrategy } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class ListType extends Type {
-    readonly itemType: Type;
-    readonly kind = "ListType";
-    private readonly identifierNodeKind;
-    private readonly identifierMintingStrategy;
     private readonly _mutable;
+    private readonly identifierMintingStrategy;
+    private readonly identifierNodeKind;
     private readonly toRdfTypes;
-    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }: {
+    readonly itemType: Type;
+    readonly kind = "ListType";
+    readonly typeof = "object";
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         mutable: boolean;
         toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof Type>[0]);
+    });
     get conversions(): readonly Type.Conversion[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(features: Set<TsFeature>): readonly string[];
-    sparqlConstructTemplateTriples({ variables, context, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ variables, context, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
+    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(features: Set<TsFeature>): readonly Import[];
+    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
 }
 //# sourceMappingURL=ListType.d.ts.map