@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/ts/ZodGenerator.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "ts-log";
+import type * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+export declare class ZodGenerator implements Generator {
+    private readonly logger;
+    constructor({ logger }: {
+        logger: Logger;
+    });
+    generate(ast_: ast.Ast): string;
+}
+//# sourceMappingURL=ZodGenerator.d.ts.map

package/dist/generators/ts/ZodGenerator.js

@@ -0,0 +1,60 @@
+import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
+import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
+import { Reusables } from "./Reusables.js";
+import { TsGenerator } from "./TsGenerator.js";
+import { TypeFactory } from "./TypeFactory.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class ZodGenerator {
+    logger;
+    constructor({ logger }) {
+        this.logger = logger;
+    }
+    generate(ast_) {
+        const configuration = TsGenerator.Configuration.finalize(ast_, TsGenerator.Configuration.default_);
+        const reusables = new Reusables({ configuration, logger: this.logger });
+        const typeFactory = new TypeFactory({
+            configuration,
+            logger: this.logger,
+            reusables,
+        });
+        const declarations = [];
+        for (const astNamedType of ast_.namedTypes) {
+            switch (astNamedType.kind) {
+                case "Struct": {
+                    const tsNamedObjectType = typeFactory.createObjectType(astNamedType);
+                    declarations.push(code `\
+export namespace ${tsNamedObjectType.name.unsafeCoerce()} {
+  export type Json = ${ObjectType_jsonTypeExpression.call(tsNamedObjectType)};
+
+  export namespace Json {
+    export function schema() {
+      return ${ObjectType_jsonSchemaExpression.call(tsNamedObjectType)};
+    }
+  }
+}`);
+                    break;
+                }
+                case "Union": {
+                    const tsNamedUnionType = typeFactory.createUnionType(astNamedType);
+                    declarations.push(code `\
+export namespace ${tsNamedUnionType.name.unsafeCoerce()} {
+  ${tsNamedUnionType.jsonTypeAliasDeclaration}
+  export namespace Json {
+    ${tsNamedUnionType.jsonSchemaFunctionDeclaration}
+  }
+}`);
+                    break;
+                }
+                default: {
+                    const type = typeFactory.createType(astNamedType);
+                    type.declaration.ifJust((declaration) => {
+                        declarations.push(declaration);
+                    });
+                }
+            }
+        }
+        declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
+        return joinCode(declarations, { on: "\n\n" }).toString({});
+    }
+}
+//# sourceMappingURL=ZodGenerator.js.map

package/dist/generators/ts/_ObjectType/AbstractProperty.d.ts

@@ -0,0 +1,217 @@
+import type { Maybe } from "purify-ts";
+import type { Logger } from "ts-log";
+import type { Reusables } from "../Reusables.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import type { TsGenerator } from "../TsGenerator.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare abstract class AbstractProperty<TypeT extends Pick<Type, "expression" | "filterFunction" | "mutable" | "schema">> {
+    protected readonly configuration: TsGenerator.Configuration;
+    protected readonly logger: Logger;
+    protected readonly objectType: {
+        readonly name: Maybe<string>;
+    };
+    protected readonly reusables: Reusables;
+    /**
+     * Optional parameter to include in the parameters object of constructor function.
+     */
+    abstract readonly constructorParameter: Maybe<{
+        readonly hasQuestionToken: boolean;
+        readonly signature: Code;
+    }>;
+    /**
+     * Property declaration to include in the type declaration of the ObjectType.
+     */
+    abstract readonly declaration: Code;
+    /**
+     * Optional property in the ObjectType's filter.
+     */
+    abstract readonly filterProperty: Maybe<{
+        readonly name: string;
+        readonly type: Code;
+    }>;
+    /**
+     * GraphQL.js field definition.
+     */
+    abstract readonly graphqlField: Maybe<{
+        args: Maybe<Record<string, {
+            type: Code;
+        }>>;
+        description: Maybe<string>;
+        name: string;
+        resolve: Code;
+        type: Code;
+    }>;
+    /**
+     * Parameter to include in the expression of the ObjectType passed to its hash function.
+     *
+     * Only specified if different from declaration.
+     */
+    abstract readonly hashFunctionParameter: Code;
+    /**
+     * zod object key: schema.
+     */
+    abstract readonly jsonSchema: Maybe<{
+        readonly key: string;
+        readonly schema: Code;
+    }>;
+    /**
+     * Signature of the property when serialized to JSON.
+     */
+    abstract readonly jsonSignature: Maybe<Code>;
+    /**
+     * Property type discriminant e.g., "Shacl".
+     */
+    abstract readonly kind: string;
+    /**
+     * Is the property reassignable?
+     */
+    abstract readonly mutable: boolean;
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
+    readonly name: string;
+    /**
+     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
+     */
+    abstract readonly recursive: boolean;
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    abstract readonly schema: Maybe<Code>;
+    /**
+     * TypeScript type describing .schema.
+     */
+    abstract readonly schemaType: Maybe<Code>;
+    /**
+     * Property type
+  .   */
+    readonly type: TypeT;
+    constructor({ configuration, logger, name, objectType, reusables, type, }: {
+        configuration: TsGenerator.Configuration;
+        logger: Logger;
+        name: string;
+        objectType: {
+            readonly name: Maybe<string>;
+        };
+        reusables: Reusables;
+        type: TypeT;
+    });
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }: {
+        variables: {
+            object: Code;
+        };
+    }): Code;
+    /**
+     * Initializer (name: value) from a constructor parameter.
+     */
+    abstract constructorInitializer(parameters: {
+        variables: {
+            parameters: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Initializer (name: value) from a JSON object.
+     */
+    abstract fromJsonInitializer(parameters: {
+        variables: {
+            jsonObject: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Initializer (name: value) from a rdfjsResource.Resource to a Either<Error, this property type>.
+     */
+    abstract fromRdfResourceValuesInitializer(parameters: {
+        variables: {
+            focusResource: Code;
+            options: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Statements to hash this property using a hasher instance.
+     */
+    abstract hashStatements(parameters: {
+        variables: {
+            hasher: Code;
+            value: Code;
+        };
+    }): readonly Code[];
+    /**
+     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
+     */
+    abstract jsonUiSchemaElement(parameters: {
+        variables: {
+            scopePrefix: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * SPARQL.js CONSTRUCT template triples for this property.
+     *
+     * Parameters:
+     *   variables: runtime variables
+     *     - filter: an instance of the object's filterType or undefined
+     *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - variablePrefix: prefix to use for new SPARQL variables
+     *
+     * Returns a (runtime) array of sparqljs.Triple.
+     */
+    abstract sparqlConstructTriplesExpression(parameters: {
+        variables: {
+            filter: Code;
+            focusIdentifier: Code;
+            variablePrefix: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * SPARQL where patterns for this property.
+     *
+     * Parameters:
+     *   variables: (at runtime)
+     *     - filter: an instance of the object's filterType or undefined
+     *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - preferredLanguages: array of preferred language code (strings)
+     *     - variablePrefix: prefix to use for new SPARQL variables
+     *
+     * Returns:
+     *   - condition: optional runtime condition to evaluate in an if statement before including the patterns
+     *   - patterns: runtime array of SparqlPattern's.
+     */
+    abstract sparqlWherePatternsExpression(parameters: {
+        variables: {
+            filter: Code;
+            focusIdentifier: Code;
+            preferredLanguages: Code;
+            variablePrefix: Code;
+        };
+    }): Maybe<{
+        condition?: Code;
+        patterns: Code;
+    }>;
+    /**
+     * Initializer (name: value) to JSON.
+     */
+    abstract toJsonInitializer(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Statements to serialize this property to an RDF resource.
+     */
+    abstract toRdfRdfResourceValuesStatements(parameters: {
+        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
+    }): readonly Code[];
+    /**
+     * Initializer (name: value) to serialize this property to a human-readable string (toString).
+     */
+    abstract toStringInitializer(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Maybe<Code>;
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
+}
+//# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -0,0 +1,37 @@
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { code } from "../ts-poet-wrapper.js";
+export class AbstractProperty {
+    configuration;
+    logger;
+    objectType;
+    reusables;
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
+    name;
+    /**
+     * Property type
+  .   */
+    type;
+    constructor({ configuration, logger, name, objectType, reusables, type, }) {
+        this.configuration = configuration;
+        this.logger = logger;
+        this.name = name;
+        this.objectType = objectType;
+        this.reusables = reusables;
+        this.type = type;
+        this.rdfjsTermExpression = rdfjsTermExpression.bind({
+            imports: this.reusables.imports,
+            logger: this.logger,
+            snippets: this.reusables.snippets,
+        });
+    }
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }) {
+        return code `${variables.object}.${this.name}`;
+    }
+    rdfjsTermExpression;
+}
+//# sourceMappingURL=AbstractProperty.js.map

package/dist/generators/ts/_ObjectType/DiscriminantProperty.d.ts

@@ -0,0 +1,45 @@
+import { Maybe } from "purify-ts";
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
+    readonly constructorParameter: AbstractProperty<DiscriminantProperty.Type>["constructorParameter"];
+    readonly declaration: Code;
+    readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
+    readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
+    readonly hashFunctionParameter: Code;
+    readonly jsonName = "@type";
+    readonly jsonSignature: Maybe<Code>;
+    readonly kind = "Discriminant";
+    readonly mutable = false;
+    readonly recursive = false;
+    readonly schema: Maybe<Code>;
+    readonly schemaType: Maybe<Code>;
+    readonly value: string;
+    constructor({ value, ...superParameters }: {
+        value: string;
+    } & Omit<ConstructorParameters<typeof AbstractProperty>[0], "type">);
+    get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
+    get values(): readonly string[];
+    private get constValue();
+    constructorInitializer(): Maybe<Code>;
+    fromJsonInitializer(): Maybe<Code>;
+    fromRdfResourceValuesInitializer(): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression(): Maybe<Code>;
+    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
+    toJsonInitializer({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
+    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringInitializer(): Maybe<Code>;
+}
+export declare namespace DiscriminantProperty {
+    class Type {
+        readonly value: string;
+        readonly filterFunction: Code;
+        readonly mutable = false;
+        constructor(value: string);
+        get expression(): Code;
+        get schema(): Code;
+    }
+}
+//# sourceMappingURL=DiscriminantProperty.d.ts.map

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

@@ -0,0 +1,104 @@
+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 { Memoize } from "typescript-memoize";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export class DiscriminantProperty extends AbstractProperty {
+    constructorParameter = Maybe.empty();
+    declaration = code `readonly ${this.name}: ${this.type.expression};`;
+    filterProperty = Maybe.empty();
+    graphqlField = Maybe.empty();
+    hashFunctionParameter = code `readonly ${this.name}?: ${this.type.expression};`;
+    jsonName = "@type";
+    jsonSignature = Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
+    kind = "Discriminant";
+    mutable = false;
+    recursive = false;
+    schema = Maybe.empty();
+    schemaType = Maybe.empty();
+    value;
+    constructor({ value, ...superParameters }) {
+        super({ ...superParameters, type: new DiscriminantProperty.Type(value) });
+        this.value = value;
+    }
+    get jsonSchema() {
+        return Maybe.of({
+            key: this.jsonName,
+            schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
+        });
+    }
+    get values() {
+        return [this.value];
+    }
+    get constValue() {
+        return code `${literalOf(this.value)} as const`;
+    }
+    constructorInitializer() {
+        return Maybe.empty();
+    }
+    fromJsonInitializer() {
+        return Maybe.empty();
+    }
+    fromRdfResourceValuesInitializer() {
+        return Maybe.empty();
+    }
+    hashStatements({ variables, }) {
+        return [
+            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}); }`,
+        ];
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
+        return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.constValue} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+    }
+    sparqlConstructTriplesExpression() {
+        return Maybe.empty();
+    }
+    sparqlWherePatternsExpression() {
+        return Maybe.empty();
+    }
+    toJsonInitializer({ variables, }) {
+        return Maybe.of(code `"${this.jsonName}": ${variables.value}`);
+    }
+    toRdfRdfResourceValuesStatements() {
+        return [];
+    }
+    toStringInitializer() {
+        return Maybe.empty();
+    }
+}
+__decorate([
+    Memoize()
+], DiscriminantProperty.prototype, "jsonSchema", null);
+__decorate([
+    Memoize()
+], DiscriminantProperty.prototype, "values", null);
+(function (DiscriminantProperty) {
+    class Type {
+        value;
+        filterFunction = code `nonextant`;
+        mutable = false;
+        constructor(value) {
+            this.value = value;
+        }
+        get expression() {
+            return code `${literalOf(this.value)}`;
+        }
+        get schema() {
+            throw new Error("should never be called");
+        }
+    }
+    __decorate([
+        Memoize()
+    ], Type.prototype, "expression", null);
+    __decorate([
+        Memoize()
+    ], Type.prototype, "schema", null);
+    DiscriminantProperty.Type = Type;
+})(DiscriminantProperty || (DiscriminantProperty = {}));
+//# sourceMappingURL=DiscriminantProperty.js.map

package/dist/generators/ts/_ObjectType/IdentifierProperty.d.ts

@@ -0,0 +1,43 @@
+import { Maybe } from "purify-ts";
+import type { BlankNodeType } from "../BlankNodeType.js";
+import type { IdentifierType } from "../IdentifierType.js";
+import type { IriType } from "../IriType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
+    readonly kind = "Identifier";
+    readonly mutable = false;
+    readonly recursive = false;
+    get constructorParameter(): Maybe<{
+        hasQuestionToken: boolean;
+        signature: Code;
+    }>;
+    get declaration(): Code;
+    get filterProperty(): Maybe<{
+        name: string;
+        type: Code;
+    }>;
+    get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
+    get hashFunctionParameter(): Code;
+    get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
+    get jsonSignature(): Maybe<Code>;
+    get schema(): Maybe<Code>;
+    get schemaType(): Maybe<Code>;
+    private get typeExpression();
+    private get typeSchemaVariable();
+    accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
+    constructorInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
+    fromJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;
+    fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression(): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["sparqlWherePatternsExpression"]>[0]): Maybe<{
+        condition: Code;
+        patterns: Code;
+    }>;
+    toJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonInitializer"]>[0]): Maybe<Code>;
+    toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringInitializer(parameters: Parameters<AbstractProperty<IdentifierType>["toStringInitializer"]>[0]): Maybe<Code>;
+}
+//# sourceMappingURL=IdentifierProperty.d.ts.map