@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/ts/ObjectUnionType.js

@@ -0,0 +1,223 @@
+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 { PropertyPath } from "@rdfx/resource";
+import { pascalCase } from "change-case";
+import { Memoize } from "typescript-memoize";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { singleEntryRecord } from "./singleEntryRecord.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { UnionType } from "./UnionType.js";
+export class ObjectUnionType extends UnionType {
+    kind = "ObjectUnion";
+    get identifierTypeAlias() {
+        return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
+    }
+    get objectSetMethodNames() {
+        return this.name
+            .map((name) => ObjectType_objectSetMethodNames.call({
+            name,
+            configuration: this.configuration,
+        }))
+            .unsafeCoerce();
+    }
+    get schema() {
+        return this.name
+            .map((name) => code `${name}.schema`)
+            .orDefault(super.schema);
+    }
+    get schemaType() {
+        return this.name
+            .map(() => code `typeof ${this.schema}`)
+            .orDefault(super.schemaType);
+    }
+    get staticModuleDeclarations() {
+        const name = this.name.unsafeCoerce();
+        return {
+            ...super.staticModuleDeclarations,
+            ...this.identifierTypeDeclarations,
+            ...this.focusSparqlConstructTriplesFunctionDeclaration,
+            ...this.focusSparqlWherePatternsFunctionDeclaration,
+            ...this.fromRdfResourceFunctionDeclaration,
+            ...this.graphqlTypeVariableStatement,
+            ...this.isTypeFunctionDeclaration,
+            ...this.schemaVariableStatement,
+            ...(this.configuration.features.has("Object.SPARQL")
+                ? {
+                    ...singleEntryRecord("sparqlConstructQuery", ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                        name,
+                        configuration: this.configuration,
+                        filterType: this.filterType,
+                        reusables: this.reusables,
+                    })),
+                    ...singleEntryRecord("sparqlConstructQueryString", ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                        name,
+                        configuration: this.configuration,
+                        filterType: this.filterType,
+                        reusables: this.reusables,
+                    })),
+                }
+                : {}),
+            ...this.toRdfResourceFunctionDeclaration,
+        };
+    }
+    get focusSparqlConstructTriplesFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.SPARQL")) {
+            return {};
+        }
+        return singleEntryRecord(`focusSparqlConstructTriples`, code `\
+export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
+  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
+}`);
+    }
+    get focusSparqlWherePatternsFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.SPARQL")) {
+            return {};
+        }
+        return singleEntryRecord(`focusSparqlWherePatterns`, code `\
+export function focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${this.reusables.snippets.SparqlPattern}[] {
+${joinCode([
+            code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
+            code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.unsafeCoerce().valueSparqlWherePatternsFunction}({
+      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.unsafeCoerce().schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+            code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
+                patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
+                type: literalOf("group"),
+            }}`), { on: ", " })}], type: "union" });`,
+            code `return patterns;`,
+        ])}
+}`);
+    }
+    get fromRdfResourceFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.fromRdf")) {
+            return {};
+        }
+        const name = this.name.unsafeCoerce();
+        return singleEntryRecord(`fromRdfResource`, code `\
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${name}> = (resource, options) => 
+  ${this.members.reduce((expression, member) => {
+            const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${name}>)`;
+            return expression !== null
+                ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+                : memberTypeExpression;
+        }, null)};`);
+    }
+    get graphqlTypeVariableStatement() {
+        if (!this.configuration.features.has("GraphQL")) {
+            return {};
+        }
+        if (this.synthetic) {
+            return {};
+        }
+        const name = this.name.unsafeCoerce();
+        return singleEntryRecord(`GraphQL`, code `\
+export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
+            description: this.comment.map(JSON.stringify).extract(),
+            name: name,
+            resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
+            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
+        }});`);
+    }
+    get identifierTypeDeclarations() {
+        if (!this.configuration.features.has("Object.type")) {
+            return {};
+        }
+        return singleEntryRecord(`Identifier`, code `\
+export type Identifier = ${this.identifierType.unsafeCoerce().expression};
+export namespace Identifier {
+  export const parse = ${this.identifierType.unsafeCoerce().parseFunction};
+  export const stringify = ${this.identifierType.unsafeCoerce().stringifyFunction};
+}`);
+    }
+    get isTypeFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.type")) {
+            return {};
+        }
+        const name = this.name.unsafeCoerce();
+        if (name === `${this.configuration.syntheticNamePrefix}Object`) {
+            return {};
+        }
+        return singleEntryRecord(`is${name}`, code `\
+    export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
+      return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
+    }`);
+    }
+    get schemaVariableStatement() {
+        if (!this.configuration.features.has("Object.schema")) {
+            return {};
+        }
+        const commonPropertiesByName = {};
+        this.members.forEach((member, memberI) => {
+            for (const memberTypeProperty of member.type.properties) {
+                if (memberTypeProperty.kind !== "Shacl") {
+                    continue;
+                }
+                let commonProperty = commonPropertiesByName[memberTypeProperty.name];
+                if (commonProperty) {
+                    if (PropertyPath.equals(commonProperty.property.path, memberTypeProperty.path)) {
+                        commonProperty.memberTypesWithProperty[memberI] = true;
+                    }
+                }
+                else {
+                    commonPropertiesByName[memberTypeProperty.name] = commonProperty = {
+                        memberTypesWithProperty: new Array(this.members.length).fill(false),
+                        property: memberTypeProperty,
+                    };
+                    commonProperty.memberTypesWithProperty[memberI] = true;
+                }
+            }
+        });
+        const propertiesObject = [];
+        for (const name of Object.keys(commonPropertiesByName).toSorted()) {
+            const { memberTypesWithProperty, property } = commonPropertiesByName[name];
+            if (!memberTypesWithProperty.every((value) => value)) {
+                continue;
+            }
+            property.schema.ifJust((propertySchema) => {
+                propertiesObject.push(code `${property.name}: ${propertySchema}`);
+            });
+        }
+        return singleEntryRecord(`schema`, code `\
+export const schema = { ${joinCode(super.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
+    }
+    get toRdfResourceFunctionDeclaration() {
+        if (!this.configuration.features.has("Object.toRdf")) {
+            return {};
+        }
+        const name = this.name.unsafeCoerce();
+        return singleEntryRecord(`toRdfResource`, code `\
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${name}> = (object, options) => {
+${joinCode(this.members
+            .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
+            .concat(code `throw new Error("unrecognized type");`))}
+};`);
+    }
+}
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "schemaType", null);
+//# sourceMappingURL=ObjectUnionType.js.map

package/dist/generators/ts/OptionType.d.ts

@@ -0,0 +1,39 @@
+import { Maybe } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
+    readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Maybe";
+        readonly typeof: "object";
+    }];
+    readonly kind = "Option";
+    get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
+    get equalsFunction(): Code;
+    get expression(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
+    get graphqlType(): AbstractContainerType.GraphqlType;
+    get hashFunction(): Code;
+    get mutable(): boolean;
+    get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
+    get validationFunction(): Maybe<Code>;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
+    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toStringExpression"]>[0]): Code;
+}
+export declare namespace OptionType {
+    type ItemType = AbstractContainerType.ItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
+}
+//# sourceMappingURL=OptionType.d.ts.map

package/dist/generators/ts/OptionType.js

@@ -0,0 +1,157 @@
+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 { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { codeEquals } from "./codeEquals.js";
+import { code } from "./ts-poet-wrapper.js";
+export class OptionType extends AbstractContainerType {
+    discriminantProperty = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    jsTypes = [
+        { instanceof: "Maybe", typeof: "object" },
+    ];
+    kind = "Option";
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        return Maybe.of({
+            code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
+            sourceTypes: itemConversionFunction.sourceTypes.concat({
+                expression: this.expression,
+                jsType: { instanceof: "Maybe", typeof: "object" },
+            }, {
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            }),
+        });
+    }
+    get equalsFunction() {
+        return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get expression() {
+        return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
+    }
+    get filterFunction() {
+        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
+    }
+    get filterType() {
+        return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
+    get graphqlType() {
+        invariant(!this.itemType.graphqlType.nullable);
+        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.expression, this.reusables, {
+            nullable: true,
+        });
+    }
+    get hashFunction() {
+        return code `${this.reusables.snippets.hashMaybe}(${this.itemType.hashFunction})`;
+    }
+    get mutable() {
+        return this.itemType.mutable;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
+    get validationFunction() {
+        return Maybe.of(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
+    }
+    fromJsonExpression({ variables, }) {
+        const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
+        const itemFromJsonExpression = this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        });
+        return code `${expression}.map(item => (${itemFromJsonExpression}).map(${this.reusables.imports.Maybe}.of)).orDefault(${this.reusables.imports.Either}.of(${this.reusables.imports.Maybe}.empty()))`;
+    }
+    graphqlResolveExpression(parameters) {
+        return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
+    }
+    jsonSchema(parameters) {
+        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
+    }
+    jsonType(parameters) {
+        const itemTypeJsonType = this.itemType.jsonType(parameters);
+        invariant(!itemTypeJsonType.optional);
+        return new AbstractContainerType.JsonType(itemTypeJsonType.expression, {
+            optional: true,
+        });
+    }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    toJsonExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const itemTypeToRdfExpression = this.itemType.toRdfResourceValuesExpression({
+            variables: { ...variables, value: code `value` },
+        });
+        let toRdfExpression = code `${variables.value}.toList()`;
+        if (!codeEquals(itemTypeToRdfExpression, code `[value]`)) {
+            toRdfExpression = code `${toRdfExpression}.flatMap((value) => ${itemTypeToRdfExpression})`;
+        }
+        return toRdfExpression;
+    }
+    toStringExpression({ variables, }) {
+        return code `${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })})).extract()`;
+    }
+}
+__decorate([
+    Memoize()
+], OptionType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "validationFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "jsonType", null);
+(function (OptionType) {
+    OptionType.isItemType = AbstractContainerType.isItemType;
+})(OptionType || (OptionType = {}));
+//# sourceMappingURL=OptionType.js.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.d.ts

@@ -0,0 +1,6 @@
+import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
+    get declaration(): Code;
+}
+//# sourceMappingURL=RdfjsDatasetObjectSetType.d.ts.map