@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/NamedObjectType.js

@@ -0,0 +1,420 @@
+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 { camelCase } from "change-case";
+import { Maybe, NonEmptyList } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
+import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_NamedObjectType/IdentifierPrefixProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
+import { identifierTypeDeclarations } from "./_NamedObjectType/identifierTypeDeclarations.js";
+import { NamedObjectType_classDeclaration } from "./_NamedObjectType/NamedObjectType_classDeclaration.js";
+import { NamedObjectType_createFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_createFunctionDeclaration.js";
+import { NamedObjectType_equalsFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_equalsFunctionOrMethodDeclaration.js";
+import { NamedObjectType_filterFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js";
+import { NamedObjectType_filterTypeDeclaration } from "./_NamedObjectType/NamedObjectType_filterTypeDeclaration.js";
+import { NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
+import { NamedObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
+import { NamedObjectType_fromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js";
+import { NamedObjectType_fromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js";
+import { NamedObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_fromRdfResourceValuesFunctionDeclaration.js";
+import { NamedObjectType_fromRdfTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_fromRdfTypeVariableStatement.js";
+import { NamedObjectType_graphqlTypeVariableStatement } from "./_NamedObjectType/NamedObjectType_graphqlTypeVariableStatement.js";
+import { NamedObjectType_hashFunctionOrMethodDeclarations } from "./_NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.js";
+import { NamedObjectType_interfaceDeclaration } from "./_NamedObjectType/NamedObjectType_interfaceDeclaration.js";
+import { NamedObjectType_isTypeFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_isTypeFunctionDeclaration.js";
+import { NamedObjectType_jsonParseFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonParseFunctionDeclaration.js";
+import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
+import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
+import { NamedObjectType_jsonUiSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js";
+import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
+import { NamedObjectType_propertiesFromJsonFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js";
+import { NamedObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js";
+import { NamedObjectType_schemaVariableStatement } from "./_NamedObjectType/NamedObjectType_schemaVariableStatement.js";
+import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { NamedObjectType_toJsonFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js";
+import { NamedObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
+import { NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
+import { NamedObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
+import { ShaclProperty as _ShaclProperty } from "./_NamedObjectType/ShaclProperty.js";
+import { AbstractType } from "./AbstractType.js";
+import { imports } from "./imports.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+export class NamedObjectType extends AbstractType {
+    imports;
+    toRdfTypes;
+    abstract;
+    declarationType;
+    extern;
+    features;
+    fromRdfType;
+    graphqlArgs = Maybe.empty();
+    identifierType;
+    kind = "NamedObjectType";
+    name;
+    recursive;
+    staticModuleName;
+    synthetic;
+    typeofs = NonEmptyList(["object"]);
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+        super(superParameters);
+        this.abstract = abstract;
+        this.declarationType = declarationType;
+        this.extern = extern;
+        this.features = features;
+        this.fromRdfType = fromRdfType;
+        this.identifierType = identifierType;
+        this.imports = imports;
+        // Lazily initialize some members in getters to avoid recursive construction
+        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
+        this.lazyChildObjectTypes = lazyChildObjectTypes;
+        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
+        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
+        this.lazyIdentifierProperty = lazyIdentifierProperty;
+        this.lazyParentObjectTypes = lazyParentObjectTypes;
+        this.lazyProperties = lazyProperties;
+        this.name = name;
+        this.recursive = recursive;
+        this.staticModuleName = staticModuleName;
+        this.synthetic = synthetic;
+        this.toRdfTypes = toRdfTypes;
+    }
+    get _discriminantProperty() {
+        return this.lazyDiscriminantProperty(this);
+    }
+    get ancestorObjectTypes() {
+        return this.lazyAncestorObjectTypes();
+    }
+    get childObjectTypes() {
+        return this.lazyChildObjectTypes();
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof ${this.name}`,
+                sourceTypeName: this.name,
+                sourceTypeof: "object",
+            },
+        ];
+    }
+    get declaration() {
+        const declarations = [];
+        for (const import_ of this.imports) {
+            declarations.push(code `${import_}`);
+        }
+        if (!this.extern) {
+            const staticModuleDeclarations = [];
+            switch (this.declarationType) {
+                case "class": {
+                    declarations.push(NamedObjectType_classDeclaration.call(this));
+                    break;
+                }
+                case "interface": {
+                    declarations.push(NamedObjectType_interfaceDeclaration.call(this));
+                    staticModuleDeclarations.push(...NamedObjectType_createFunctionDeclaration.call(this).toList(), ...NamedObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this));
+                    break;
+                }
+            }
+            const jsonModuleDeclarations = [
+                ...NamedObjectType_jsonParseFunctionDeclaration.call(this).toList(),
+                ...NamedObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
+                ...NamedObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(),
+            ];
+            staticModuleDeclarations.push(...NamedObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...NamedObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
+                ? [
+                    code `export namespace ${syntheticNamePrefix}Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
+                ]
+                : []), NamedObjectType_filterFunctionDeclaration.call(this), NamedObjectType_filterTypeDeclaration.call(this), ...NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...NamedObjectType_fromRdfTypeVariableStatement.call(this).toList(), NamedObjectType_isTypeFunctionDeclaration.call(this), ...NamedObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), NamedObjectType_schemaVariableStatement.call(this), ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
+                ? NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList()
+                : []), ...(this.declarationType === "interface"
+                ? NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList()
+                : []), ...NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
+            if (staticModuleDeclarations.length > 0) {
+                declarations.push(code `\
+export namespace ${def(this.staticModuleName)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
+            }
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get descendantFromRdfTypeVariables() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
+    }
+    get descendantFromRdfTypes() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
+    }
+    get descendantObjectTypes() {
+        return this.lazyDescendantObjectTypes();
+    }
+    get discriminantProperty() {
+        return Maybe.of({
+            name: this._discriminantProperty.name,
+            ownValues: this._discriminantProperty.type.ownValues,
+            descendantValues: this._discriminantProperty.type.descendantValues,
+        });
+    }
+    get discriminantValue() {
+        return this.name;
+    }
+    get equalsFunction() {
+        switch (this.declarationType) {
+            case "class":
+                return code `((left, right) => left.${syntheticNamePrefix}equals(right))`;
+            case "interface":
+                return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+            default:
+                throw new RangeError(this.declarationType);
+        }
+    }
+    get filterFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
+    }
+    get filterType() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
+    }
+    get fromRdfTypeVariable() {
+        return this.fromRdfType.map(() => code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfType`);
+    }
+    get graphqlType() {
+        return new AbstractType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+    }
+    get identifierProperty() {
+        return this.lazyIdentifierProperty(this);
+    }
+    get identifierTypeAlias() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+    }
+    get mutable() {
+        return this.properties.some((property) => property.mutable);
+    }
+    get objectSetMethodNames() {
+        return NamedObjectType_objectSetMethodNames.call(this);
+    }
+    get ownProperties() {
+        if (this.parentObjectTypes.length === 0) {
+            // Consider that a root of the object type hierarchy "owns" the identifier and type discriminant properties
+            // for all of its subtypes in the hierarchy.
+            // invariant(this.properties.length >= 2, this.name);
+            return this.properties;
+        }
+        return this.ownShaclProperties;
+    }
+    get ownShaclProperties() {
+        return this.properties.filter((property) => property.kind === "ShaclProperty");
+    }
+    get parentObjectTypes() {
+        return this.lazyParentObjectTypes();
+    }
+    get properties() {
+        const properties = this.lazyProperties(this);
+        const propertyNames = new Set();
+        for (const property of properties) {
+            if (propertyNames.has(property.name)) {
+                throw new Error(`duplicate property '${property.name}'`);
+            }
+        }
+        return properties;
+    }
+    get schema() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+    }
+    get schemaType() {
+        return code `typeof ${this.schema}`;
+    }
+    get toRdfjsResourceType() {
+        if (this.parentObjectTypes.length > 0) {
+            return this.parentObjectTypes[0].toRdfjsResourceType;
+        }
+        return code `${imports.Resource}${this.identifierType.kind === "IriType" ? code `<${imports.NamedNode}>` : ""}`;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
+    }
+    get thisVariable() {
+        switch (this.declarationType) {
+            case "class":
+                return code `this`;
+            case "interface":
+                return code `_${camelCase(this.name)}`;
+            default:
+                throw new RangeError(this.declarationType);
+        }
+    }
+    fromJsonExpression({ variables, }) {
+        // Assumes the JSON object has been recursively validated already.
+        return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
+    }
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues, ...options } = variables;
+        return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValues}, ${options})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    hashStatements({ variables, }) {
+        switch (this.declarationType) {
+            case "class":
+                return [
+                    code `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
+                ];
+            case "interface":
+                return [
+                    code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+                ];
+        }
+    }
+    jsonSchema({ context, }) {
+        let expression = code `${this.staticModuleName}.${syntheticNamePrefix}Json.schema()`;
+        if (context === "property" &&
+            this.properties.some((property) => property.recursive)) {
+            expression = code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+        }
+        return expression;
+    }
+    jsonType() {
+        return new AbstractType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
+    }
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(code `${this.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
+    }
+    newExpression({ parameters }) {
+        switch (this.declarationType) {
+            case "class":
+                return code `new ${this.name}(${parameters})`;
+            case "interface":
+                return code `${this.staticModuleName}.${syntheticNamePrefix}create(${parameters})`;
+        }
+    }
+    toJsonExpression({ variables, }) {
+        switch (this.declarationType) {
+            case "class":
+                return code `${variables.value}.${syntheticNamePrefix}toJson()`;
+            case "interface":
+                return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
+        }
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        switch (this.declarationType) {
+            case "class":
+                return code `[${variables.value}.${syntheticNamePrefix}toRdfResource({ graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+            case "interface":
+                return code `[${this.staticModuleName}.${syntheticNamePrefix}toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+        }
+    }
+    ensureAtMostOneSuperObjectType() {
+        if (this.parentObjectTypes.length > 1) {
+            throw new RangeError(`object type '${this.name}' has multiple super object types`);
+        }
+    }
+    lazyAncestorObjectTypes;
+    lazyChildObjectTypes;
+    lazyDescendantObjectTypes;
+    lazyDiscriminantProperty;
+    lazyIdentifierProperty;
+    lazyParentObjectTypes;
+    lazyProperties;
+}
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "_discriminantProperty", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "ancestorObjectTypes", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "childObjectTypes", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "descendantFromRdfTypeVariables", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "descendantFromRdfTypes", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "descendantObjectTypes", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "discriminantValue", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "fromRdfTypeVariable", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "identifierProperty", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "ownProperties", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "ownShaclProperties", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "parentObjectTypes", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "toRdfjsResourceType", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "thisVariable", null);
+__decorate([
+    Memoize()
+], NamedObjectType.prototype, "jsonType", null);
+(function (NamedObjectType) {
+    NamedObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
+    NamedObjectType.IdentifierProperty = _IdentifierProperty;
+    NamedObjectType.ShaclProperty = _ShaclProperty;
+    NamedObjectType.DiscriminantProperty = _DiscriminantProperty;
+})(NamedObjectType || (NamedObjectType = {}));
+//# sourceMappingURL=NamedObjectType.js.map

package/dist/generators/ts/NamedObjectUnionType.d.ts

@@ -0,0 +1,35 @@
+import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class NamedObjectUnionType extends AbstractNamedUnionType<NamedObjectType> {
+    #private;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly kind = "NamedObjectUnionType";
+    constructor({ identifierType, ...superParameters }: {
+        identifierType: BlankNodeType | IdentifierType | IriType;
+    } & Omit<ConstructorParameters<typeof AbstractNamedUnionType<NamedObjectType>>[0], "identifierType">);
+    get graphqlType(): AbstractType.GraphqlType;
+    get identifierTypeAlias(): Code;
+    get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
+    get schema(): Code;
+    get schemaType(): Code;
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    private get focusSparqlConstructTriplesFunctionDeclaration();
+    private get focusSparqlWherePatternsFunctionDeclaration();
+    private get fromRdfResourceFunctionDeclaration();
+    private get graphqlTypeVariableStatement();
+    private get identifierTypeDeclarations();
+    private get isTypeFunctionDeclaration();
+    private get schemaVariableStatement();
+    private get toRdfResourceFunctionDeclaration();
+    graphqlResolveExpression({ variables, }: {
+        variables: {
+            value: Code;
+        };
+    }): Code;
+}
+//# sourceMappingURL=NamedObjectUnionType.d.ts.map

package/dist/generators/ts/NamedObjectUnionType.js

@@ -0,0 +1,217 @@
+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 { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { PropertyPath } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
+import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
+import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
+import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+import { AbstractType } from "./AbstractType.js";
+import { imports } from "./imports.js";
+import { singleEntryRecord } from "./singleEntryRecord.js";
+import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class NamedObjectUnionType extends AbstractNamedUnionType {
+    #identifierType;
+    graphqlArgs = Maybe.empty();
+    kind = "NamedObjectUnionType";
+    constructor({ identifierType, ...superParameters }) {
+        super({ ...superParameters, identifierType: Maybe.of(identifierType) });
+        this.#identifierType = identifierType;
+    }
+    get graphqlType() {
+        return new AbstractType.GraphqlType(code `${this._name}.${syntheticNamePrefix}GraphQL`);
+    }
+    get identifierTypeAlias() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+    }
+    get objectSetMethodNames() {
+        return NamedObjectType_objectSetMethodNames.call(this);
+    }
+    get schema() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+    }
+    get schemaType() {
+        return code `typeof ${this.schema}`;
+    }
+    get staticModuleDeclarations() {
+        return {
+            ...super.staticModuleDeclarations,
+            ...this.identifierTypeDeclarations,
+            ...this.focusSparqlConstructTriplesFunctionDeclaration,
+            ...this.focusSparqlWherePatternsFunctionDeclaration,
+            ...this.fromRdfResourceFunctionDeclaration,
+            ...this.graphqlTypeVariableStatement,
+            ...this.isTypeFunctionDeclaration,
+            ...this.schemaVariableStatement,
+            ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call(this)
+                .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQuery`, code_))
+                .orDefault({}),
+            ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call(this)
+                .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQueryString`, code_))
+                .orDefault({}),
+            ...this.toRdfResourceFunctionDeclaration,
+        };
+    }
+    get focusSparqlConstructTriplesFunctionDeclaration() {
+        if (!this.features.has("sparql")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}focusSparqlConstructTriples`, code `\
+export function ${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+  return [${joinCode(this.concreteMembers.map((member) => code `...${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+}`);
+    }
+    get focusSparqlWherePatternsFunctionDeclaration() {
+        if (!this.features.has("sparql")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}focusSparqlWherePatterns`, code `\
+export function ${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${joinCode([
+            code `let patterns: ${snippets.SparqlPattern}[] = [];`,
+            code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
+      filter: filter?.${syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.#identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+            code `patterns.push({ patterns: [${joinCode(this.concreteMembers.map((member) => code `${{
+                patterns: code `${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+                type: literalOf("group"),
+            }}`), { on: ", " })}], type: "union" });`,
+            code `return patterns;`,
+        ])}
+}`);
+    }
+    get fromRdfResourceFunctionDeclaration() {
+        if (!this.features.has("rdf")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}fromRdfResource`, code `\
+export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
+  ${this.concreteMembers.reduce((expression, member) => {
+            const memberTypeExpression = code `(${member.type.staticModuleName}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+            return expression !== null
+                ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+                : memberTypeExpression;
+        }, null)};`);
+    }
+    get graphqlTypeVariableStatement() {
+        if (!this.features.has("graphql")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}GraphQL`, code `\
+export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
+            description: this.comment.map(JSON.stringify).extract(),
+            name: this.name,
+            resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
+            types: code `[${joinCode(this.concreteMembers.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
+        }});`);
+    }
+    get identifierTypeDeclarations() {
+        return singleEntryRecord(`${syntheticNamePrefix}Identifier`, code `\
+export type ${syntheticNamePrefix}Identifier = ${this.#identifierType.name};
+export namespace ${syntheticNamePrefix}Identifier { ${joinCode([this.#identifierType.fromStringFunction, this.#identifierType.toStringFunction])} }`);
+    }
+    get isTypeFunctionDeclaration() {
+        if (this._name === `${syntheticNamePrefix}Object`) {
+            return {};
+        }
+        return singleEntryRecord(`is${this._name}`, code `\
+    export function is${this._name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+      return ${joinCode(this.concreteMembers.map((member) => code `${member.type.staticModuleName}.is${member.type.name}(object)`), { on: " || " })};
+    }`);
+    }
+    get schemaVariableStatement() {
+        const commonPropertiesByName = {};
+        this.concreteMembers.forEach((member, memberI) => {
+            for (const memberTypeProperty of member.type.ownProperties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.ownProperties))) {
+                if (memberTypeProperty.kind !== "ShaclProperty") {
+                    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.concreteMembers.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;
+            }
+            propertiesObject.push(code `${property.name}: ${property.schema}`);
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}schema`, code `\
+export const ${syntheticNamePrefix}schema =
+${{
+            ...super.schemaObject,
+            properties: code `{ ${joinCode(propertiesObject, { on: ", " })} }`,
+        }} as const;`);
+    }
+    get toRdfResourceFunctionDeclaration() {
+        if (!this.features.has("rdf")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}toRdfResource`, code `\
+export const ${syntheticNamePrefix}toRdfResource: ${snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
+${joinCode(this.concreteMembers
+            .map((member) => {
+            let returnExpression;
+            switch (member.type.declarationType) {
+                case "class":
+                    returnExpression = code `value.${syntheticNamePrefix}toRdfResource(options)`;
+                    break;
+                case "interface":
+                    returnExpression = code `${member.type.staticModuleName}.${syntheticNamePrefix}toRdfResource(value, options)`;
+                    break;
+            }
+            return code `if (${member.type.staticModuleName}.is${member.type.name}(value)) { return ${returnExpression}; }`;
+        })
+            .concat(code `throw new Error("unrecognized type");`))}
+};`);
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+}
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "schemaType", null);
+//# sourceMappingURL=NamedObjectUnionType.js.map