@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/LiteralType.js

@@ -1,124 +1,45 @@
-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 { xsd } from "@tpluscode/rdf-ns-builders";
-import { Memoize } from "typescript-memoize";
-import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { TermType } from "./TermType.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class LiteralType extends TermType {
-    languageIn;
-    constructor({ languageIn, ...superParameters }) {
-        super({
-            ...superParameters,
-            nodeKinds: new Set(["Literal"]),
-        });
-        this.languageIn = languageIn;
-    }
-    get jsonName() {
-        return new Type.JsonName('{ readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string }');
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+export class LiteralType extends AbstractLiteralType {
+    filterFunction = code `${snippets.filterLiteral}`;
+    filterType = code `${snippets.LiteralFilter}`;
+    kind = "LiteralType";
+    name = code `${imports.Literal}`;
+    schemaType = code `${snippets.LiteralSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.literalSparqlWherePatterns}`;
+    get graphqlType() {
+        throw new Error("not implemented");
     }
     fromJsonExpression({ variables, }) {
-        return `dataFactory.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+        return code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]) : undefined))`;
     }
-    fromRdfExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfExpressionChain({ variables }),
-            languageIn: this.languageIn.length > 0
-                ? `chain(values => values.chainMap(value => value.toLiteral().chain(literalValue => { switch (literalValue.language) { ${this.languageIn.map((languageIn) => `case "${languageIn}":`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "literalValue", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })))`
-                : undefined,
-            preferredLanguages: `chain(values => {
-        if (!${variables.preferredLanguages} || ${variables.preferredLanguages}.length === 0) {
-          return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
-        }
-
-        const literalValuesEither = values.chainMap(value => value.toLiteral());
-        if (literalValuesEither.isLeft()) {
-          return literalValuesEither;
-        }
-        const literalValues = literalValuesEither.unsafeCoerce();
-
-        // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-        // Within a preferredLanguage the literals may be in any order.
-        let filteredLiteralValues: rdfjsResource.Resource.Values<rdfjs.Literal> | undefined;
-        for (const preferredLanguage of ${variables.preferredLanguages}) {
-          if (!filteredLiteralValues) {
-            filteredLiteralValues = literalValues.filter(value => value.language === preferredLanguage);
-          } else {
-            filteredLiteralValues = filteredLiteralValues.concat(...literalValues.filter(value => value.language === preferredLanguage).toArray());
-          }
-        }
-
-        return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(filteredLiteralValues!.map(literalValue => new rdfjsResource.Resource.Value({ object: literalValue, predicate: ${variables.predicate}, subject: ${variables.resource} })));
-      })`,
-            valueTo: "chain(values => values.chainMap(value => value.toLiteral()))",
-        };
+    graphqlResolveExpression(_parameters) {
+        throw new Error("not implemented");
     }
     hashStatements({ depth, variables, }) {
         return [
-            `${variables.hasher}.update(${variables.value}.datatype.value);`,
-            `${variables.hasher}.update(${variables.value}.language);`,
-        ].concat(super.hashStatements({ depth, variables }));
-    }
-    jsonZodSchema({ variables, }) {
-        return `${variables.zod}.object({ "@language": ${variables.zod}.string().optional(), "@type": ${variables.zod}.string().optional(), "@value": ${variables.zod}.string() })`;
-    }
-    snippetDeclarations(parameters) {
-        let snippetDeclarations = super.snippetDeclarations(parameters);
-        const { features } = parameters;
-        if (features.has("sparql") && this.languageIn.length > 0) {
-            snippetDeclarations = snippetDeclarations.concat(SnippetDeclarations.arrayIntersection);
-        }
-        return snippetDeclarations;
-    }
-    sparqlWherePatterns(parameters) {
-        const { context, ignoreLiteralLanguage, variables } = parameters;
-        const superPatterns = super.sparqlWherePatterns(parameters);
-        if (ignoreLiteralLanguage || context === "subject") {
-            return superPatterns;
-        }
-        return superPatterns.concat(`...[${this.languageIn.length > 0
-            ? `[...${syntheticNamePrefix}arrayIntersection(${JSON.stringify(this.languageIn)}, ${variables.preferredLanguages} ?? [])]`
-            : `(${variables.preferredLanguages} ?? [])`}]
-        .filter(languages => languages.length > 0)
-        .map(languages =>
-          languages.map(language => 
-            ({
-              type: "operation" as const,
-              operator: "=",
-              args: [
-                { type: "operation" as const, operator: "lang", args: [${variables.object}] },
-                dataFactory.literal(language)
-              ]
-            })
-          )
-        )
-        .map(langEqualsExpressions => 
-          ({
-            type: "filter" as const,
-            expression: langEqualsExpressions.reduce((reducedExpression, langEqualsExpression) => {
-              if (reducedExpression === null) {
-                return langEqualsExpression;
-              }
-              return {
-                type: "operation" as const,
-                operator: "||",
-                args: [reducedExpression, langEqualsExpression]
-              };
-            }, null as sparqljs.Expression | null) as sparqljs.Expression
-          })
-        )`);
-    }
-    toJsonExpression({ variables, }) {
-        return `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
+            ...super.hashStatements({ depth, variables }),
+            code `${variables.hasher}.update(${variables.value}.datatype.value);`,
+            code `${variables.hasher}.update(${variables.value}.language);`,
+        ];
+    }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "Literal"`
+            : "";
+        return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
+    }
+    jsonZodSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${imports.z}.literal("Literal")`
+            : "";
+        return code `${imports.z}.object({ "@language": ${imports.z}.string().optional()${discriminantProperty}, "@type": ${imports.z}.string().optional(), "@value": ${imports.z}.string() })`;
+    }
+    toJsonExpression({ includeDiscriminantProperty, variables, }) {
+        return code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
     }
 }
-__decorate([
-    Memoize()
-], LiteralType.prototype, "jsonName", null);
 //# sourceMappingURL=LiteralType.js.map

package/dist/generators/ts/ObjectType.d.ts

@@ -1,32 +1,38 @@
 import type { NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import * as _ObjectType from "./_ObjectType/index.js";
+import { Maybe, NonEmptyList } from "purify-ts";
 import type { IdentifierMintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
-import { DeclaredType } from "./DeclaredType.js";
+import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
+import type { Property as _Property } from "./_ObjectType/Property.js";
+import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
+import { TypeDiscriminantProperty as _TypeDiscriminantProperty } from "./_ObjectType/TypeDiscriminantProperty.js";
+import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
-import { Import } from "./Import.js";
-import { Type } from "./Type.js";
-export declare class ObjectType extends DeclaredType {
+import type { IriType } from "./IriType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class ObjectType extends AbstractDeclaredType {
     private readonly imports;
-    protected readonly comment: Maybe<string>;
-    protected readonly label: Maybe<string>;
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly abstract: boolean;
     readonly declarationType: TsObjectDeclarationType;
     readonly extern: boolean;
     readonly fromRdfType: Maybe<NamedNode>;
+    readonly graphqlArgs: AbstractDeclaredType["graphqlArgs"];
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly kind = "ObjectType";
     readonly staticModuleName: string;
     readonly synthetic: boolean;
-    readonly typeof = "object";
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, imports, label, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
+    readonly typeofs: NonEmptyList<"object">;
+    constructor({ abstract, declarationType, extern, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
         extern: boolean;
         fromRdfType: Maybe<NamedNode>;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
+        identifierType: BlankNodeType | IdentifierType | IriType;
         imports: readonly string[];
         label: Maybe<string>;
         lazyAncestorObjectTypes: () => readonly ObjectType[];
@@ -37,52 +43,52 @@ export declare class ObjectType extends DeclaredType {
         staticModuleName: string;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof DeclaredType>[0]);
-    get _discriminatorProperty(): Type.DiscriminatorProperty;
+    } & ConstructorParameters<typeof AbstractDeclaredType>[0]);
+    get _discriminantProperty(): AbstractDeclaredType.DiscriminantProperty;
     get ancestorObjectTypes(): readonly ObjectType[];
     get childObjectTypes(): readonly ObjectType[];
-    get conversions(): readonly Type.Conversion[];
-    get declarationImports(): readonly Import[];
-    get declarations(): (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
+    get conversions(): readonly AbstractDeclaredType.Conversion[];
+    get declaration(): Code;
+    get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantFromRdfTypeVariables(): readonly string[];
     get descendantObjectTypes(): readonly ObjectType[];
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get discriminatorValue(): string;
-    get equalsFunction(): string;
-    get fromRdfTypeVariable(): Maybe<string>;
-    get graphqlName(): Type.GraphqlName;
+    get discriminantProperty(): Maybe<AbstractDeclaredType.DiscriminantProperty>;
+    get discriminantValue(): string;
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get fromRdfTypeVariable(): Maybe<Code>;
+    get graphqlType(): AbstractDeclaredType.GraphqlType;
     get identifierProperty(): ObjectType.IdentifierProperty;
-    get identifierType(): IdentifierType;
-    get identifierTypeAlias(): string;
-    get jsonName(): Type.JsonName;
+    get identifierTypeAlias(): Code;
     get mutable(): boolean;
-    newExpression({ parameters }: {
-        parameters: string;
-    }): string;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get ownProperties(): readonly ObjectType.Property[];
-    get ownShaclProperties(): readonly ObjectType.Property[];
+    get ownShaclProperties(): readonly ObjectType.ShaclProperty<Type>[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
-    get toRdfjsResourceType(): string;
-    protected get thisVariable(): string;
-    fromJsonExpression({ variables, }: Parameters<DeclaredType["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<DeclaredType["fromRdfExpression"]>[0]): string;
+    get schema(): Code;
+    get schemaType(): Code;
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    get toRdfjsResourceType(): Code;
+    protected get thisVariable(): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractDeclaredType["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression({ variables, }: Parameters<AbstractDeclaredType["fromRdfExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
-            value: string;
+            value: Code;
         };
-    }): string;
-    hashStatements({ variables, }: Parameters<DeclaredType["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement({ variables, }: Parameters<DeclaredType["jsonUiSchemaElement"]>[0]): Maybe<string>;
-    jsonZodSchema({ context, variables, }: Parameters<DeclaredType["jsonZodSchema"]>[0]): ReturnType<DeclaredType["jsonZodSchema"]>;
-    snippetDeclarations({ recursionStack, }: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
-    sparqlConstructTemplateTriples(parameters: Parameters<DeclaredType["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<DeclaredType["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<DeclaredType["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<DeclaredType["toRdfExpression"]>[0]): string;
-    useImports(): readonly Import[];
+    }): Code;
+    hashStatements({ variables, }: Parameters<AbstractDeclaredType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractDeclaredType.JsonType;
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractDeclaredType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    jsonZodSchema({ context, }: Parameters<AbstractDeclaredType["jsonZodSchema"]>[0]): Code;
+    newExpression({ parameters }: {
+        parameters: Code;
+    }): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractDeclaredType["toJsonExpression"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractDeclaredType["toRdfExpression"]>[0]): Code;
     protected ensureAtMostOneSuperObjectType(): void;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyChildObjectTypes;
@@ -91,32 +97,20 @@ export declare class ObjectType extends DeclaredType {
     private readonly lazyProperties;
 }
 export declare namespace ObjectType {
-    const EagerShaclProperty: typeof _ObjectType.EagerShaclProperty;
-    type EagerShaclProperty<TypeT extends Type = Type> = _ObjectType.EagerShaclProperty<TypeT>;
-    const IdentifierPrefixProperty: typeof _ObjectType.IdentifierPrefixProperty;
-    type IdentifierPrefixProperty = _ObjectType.IdentifierPrefixProperty;
-    const IdentifierProperty: typeof _ObjectType.IdentifierProperty;
-    type IdentifierProperty = _ObjectType.IdentifierProperty;
-    const LazyShaclProperty: typeof _ObjectType.LazyShaclProperty;
-    type LazyShaclProperty<LazyTypeT extends _ObjectType.LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>, ResolvedTypeT extends _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends _ObjectType.LazyShaclProperty.Type.StubTypeConstraint> = _ObjectType.LazyShaclProperty<LazyTypeT, ResolvedTypeT, StubTypeT>;
-    namespace LazyShaclProperty {
-        type Type<ResolvedTypeT extends _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends _ObjectType.LazyShaclProperty.Type.StubTypeConstraint> = _ObjectType.LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>;
-        namespace Type {
-            type ResolvedTypeConstraint = _ObjectType.LazyShaclProperty.Type.ResolvedTypeConstraint;
-            type StubTypeConstraint = _ObjectType.LazyShaclProperty.Type.StubTypeConstraint;
-        }
-    }
+    const IdentifierPrefixProperty: typeof _IdentifierPrefixProperty;
+    type IdentifierPrefixProperty = _IdentifierPrefixProperty;
+    const IdentifierProperty: typeof _IdentifierProperty;
+    type IdentifierProperty = _IdentifierProperty;
     type ObjectSetMethodNames = {
         readonly object: string;
-        readonly objectsCount: string;
+        readonly objectCount: string;
         readonly objectIdentifiers: string;
         readonly objects: string;
     };
-    const Property: typeof _ObjectType.Property;
-    type Property = _ObjectType.Property<any>;
-    const ShaclProperty: typeof _ObjectType.ShaclProperty;
-    type ShaclProperty<TypeT extends Type> = _ObjectType.ShaclProperty<TypeT>;
-    const TypeDiscriminatorProperty: typeof _ObjectType.TypeDiscriminatorProperty;
-    type TypeDiscriminatorProperty = _ObjectType.TypeDiscriminatorProperty;
+    type Property = _Property;
+    const ShaclProperty: typeof _ShaclProperty;
+    type ShaclProperty<TypeT extends Type> = _ShaclProperty<TypeT>;
+    const TypeDiscriminantProperty: typeof _TypeDiscriminantProperty;
+    type TypeDiscriminantProperty = _TypeDiscriminantProperty;
 }
 //# sourceMappingURL=ObjectType.d.ts.map