soukai-bis 0.0.0

package/dist/soukai-bis.d.ts

@@ -0,0 +1,78 @@
+import { Constructor } from '@noeldemartin/utils';
+import { JsonLD } from '@noeldemartin/solid-utils';
+import { MagicObject } from '@noeldemartin/utils';
+import { NamedNode } from '@rdfjs/types';
+import { z } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodType } from 'zod';
+
+declare namespace coreExtensions {
+    export {
+        rdfProperty,
+        CustomMeta
+    }
+}
+
+declare interface CustomMeta {
+    rdfProperty?: string;
+}
+
+export declare function defineSchema<T extends SchemaFields>(config: SchemaConfig<T>): SchemaModel<T>;
+
+export declare class Model extends MagicObject {
+    static schema: Schema;
+    static<T extends typeof Model>(): T;
+    static<T extends typeof Model, K extends keyof T>(property: K): T[K];
+    url?: string;
+    private __attributes;
+    constructor(attributes?: Record<string, unknown>);
+    getAttributes(): Record<string, unknown>;
+    toJsonLD(): Promise<JsonLD>;
+    toTurtle(): Promise<string>;
+    protected __get(property: string): unknown;
+}
+
+export declare function patchZod(): void;
+
+declare function rdfProperty<T extends ZodType>(this: T): string | undefined;
+
+declare function rdfProperty<T extends ZodType>(this: T, value: string): T;
+
+export declare type Schema<T extends SchemaFields = SchemaFields> = {
+    fields: ZodObject<T>;
+    rdfContext: {
+        default: string;
+    } & Record<string, string>;
+    rdfClasses: NamedNode[];
+    rdfDefaultResourceHash: string;
+    rdfFieldProperties: Record<string, NamedNode>;
+};
+
+export declare interface SchemaConfig<T extends SchemaFields> {
+    crdts?: boolean;
+    rdfContext?: string;
+    rdfClass?: string;
+    rdfDefaultResourceHash?: string;
+    fields: T;
+    relations?: Record<string, unknown>;
+}
+
+export declare type SchemaFields = Record<string, ZodType>;
+
+export declare type SchemaModel<T extends SchemaFields> = typeof Model & Constructor<z.infer<ZodObject<T>>>;
+
+export declare type ZodCoreExtensions = typeof coreExtensions;
+
+export { }
+
+
+declare module 'zod' {
+    interface ZodType extends ZodCoreExtensions {
+    }
+}
+
+
+declare module 'zod' {
+    interface GlobalMeta extends CustomMeta {
+    }
+}

package/dist/soukai-bis.js

@@ -0,0 +1,103 @@
+var j = Object.defineProperty;
+var x = (t, r, e) => r in t ? j(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
+var f = (t, r, e) => x(t, typeof r != "symbol" ? r + "" : r, e);
+import { ZodArray as C, ZodURL as R, ZodOptional as m, ZodDefault as b, object as P, z as F } from "zod";
+import { MagicObject as O } from "@noeldemartin/utils";
+import { expandIRI as c, RDFNamedNode as u, RDFQuad as p, RDFLiteral as w, quadsToJsonLD as g, quadsToTurtle as Z } from "@noeldemartin/solid-utils";
+const A = c("rdf:type");
+function d(t) {
+  return t instanceof m || t instanceof b ? d(t.def.innerType) : t;
+}
+function _(t, r) {
+  const e = d(r);
+  return e instanceof C ? (Array.isArray(t) ? t : t == null ? [] : [t]).flatMap((s) => _(s, e.def.element)) : e instanceof R ? [new u(String(t))] : [new w(String(t))];
+}
+function h(t) {
+  const { fields: r, rdfDefaultResourceHash: e, rdfClasses: n, rdfFieldProperties: s } = t.static().schema, i = new u(t.url ?? `#${e}`), o = [];
+  for (const a of n)
+    o.push(new p(i, A, a));
+  for (const [a, y] of Object.entries(t.getAttributes()))
+    for (const D of _(y, r.def.shape[a]))
+      o.push(new p(i, s[a], D));
+  return o;
+}
+class T extends O {
+  constructor(e = {}) {
+    super();
+    f(this, "__attributes");
+    if (this.static().isConjuring()) {
+      this.__attributes = {};
+      return;
+    }
+    this.__attributes = this.static().schema.fields.parse(e);
+  }
+  static(e) {
+    return super.static(e);
+  }
+  getAttributes() {
+    return this.__attributes;
+  }
+  async toJsonLD() {
+    return g(h(this));
+  }
+  async toTurtle() {
+    return Z(h(this));
+  }
+  __get(e) {
+    return this.__attributes[e];
+  }
+}
+f(T, "schema");
+function V(t) {
+  var s;
+  const r = t.rdfContext ? { default: t.rdfContext } : { default: "solid" }, { default: e, ...n } = r;
+  return s = class extends T {
+  }, f(s, "schema", {
+    fields: P(t.fields),
+    rdfContext: r,
+    rdfDefaultResourceHash: t.rdfDefaultResourceHash ?? "it",
+    rdfClasses: t.rdfClass ? [
+      new u(
+        c(t.rdfClass, {
+          defaultPrefix: e,
+          extraContext: n
+        })
+      )
+    ] : [],
+    rdfFieldProperties: Object.fromEntries(
+      Object.entries(t.fields).map(([i, o]) => [
+        i,
+        new u(
+          c(o.rdfProperty() ?? i, {
+            defaultPrefix: e,
+            extraContext: n
+          })
+        )
+      ])
+    )
+  }), s;
+}
+function l(t, r) {
+  const e = t.meta();
+  if (e && r in e)
+    return e[r];
+  if (t instanceof b || t instanceof m)
+    return l(t.def.innerType, r);
+}
+function S(t) {
+  return typeof t != "string" ? l(this, "rdfProperty") : this.meta({ rdfProperty: t });
+}
+const L = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  rdfProperty: S
+}, Symbol.toStringTag, { value: "Module" }));
+function q() {
+  for (const [t, r] of Object.entries(L))
+    F.ZodType.prototype[t] = r;
+}
+export {
+  T as Model,
+  V as defineSchema,
+  q as patchZod
+};
+//# sourceMappingURL=soukai-bis.js.map

package/dist/soukai-bis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"soukai-bis.js","sources":["../src/models/constants.ts","../src/models/concerns/serializes-to-rdf.ts","../src/models/Model.ts","../src/models/schema.ts","../src/zod/extensions/core.ts","../src/zod/index.ts"],"sourcesContent":["import { expandIRI } from '@noeldemartin/solid-utils';\n\nexport const RDF_TYPE = expandIRI('rdf:type');\n","import { ZodArray, ZodDefault, ZodOptional, ZodURL } from 'zod';\nimport { RDFLiteral, RDFNamedNode, RDFQuad } from '@noeldemartin/solid-utils';\nimport type { Quad, Quad_Object } from '@rdfjs/types';\nimport type { SomeType } from 'zod/v4/core';\n\nimport { RDF_TYPE } from 'soukai-bis/models/constants';\nimport type Model from 'soukai-bis/models/Model';\n\nfunction getFinalType(type: SomeType): SomeType {\n    if (type instanceof ZodOptional) {\n        return getFinalType(type.def.innerType);\n    }\n\n    if (type instanceof ZodDefault) {\n        return getFinalType(type.def.innerType);\n    }\n\n    return type;\n}\n\nfunction castValue(value: unknown, type: SomeType): Quad_Object[] {\n    const finalType = getFinalType(type);\n\n    if (finalType instanceof ZodArray) {\n        const arrayValue = Array.isArray(value) ? value : value === null || value === undefined ? [] : [value];\n\n        return arrayValue.flatMap((item) => castValue(item, finalType.def.element));\n    }\n\n    if (finalType instanceof ZodURL) {\n        return [new RDFNamedNode(String(value))];\n    }\n\n    return [new RDFLiteral(String(value))];\n}\n\nexport function serializeToRDF(model: Model): Quad[] {\n    const { fields, rdfDefaultResourceHash, rdfClasses, rdfFieldProperties } = model.static().schema;\n    const subject = new RDFNamedNode(model.url ?? `#${rdfDefaultResourceHash}`);\n    const statements: Quad[] = [];\n\n    for (const rdfClass of rdfClasses) {\n        statements.push(new RDFQuad(subject, RDF_TYPE, rdfClass));\n    }\n\n    for (const [field, value] of Object.entries(model.getAttributes())) {\n        for (const object of castValue(value, fields.def.shape[field])) {\n            statements.push(new RDFQuad(subject, rdfFieldProperties[field], object));\n        }\n    }\n\n    return statements;\n}\n","import { MagicObject } from '@noeldemartin/utils';\nimport { quadsToJsonLD, quadsToTurtle } from '@noeldemartin/solid-utils';\nimport type { JsonLD } from '@noeldemartin/solid-utils';\n\nimport { serializeToRDF } from './concerns/serializes-to-rdf';\nimport type { Schema } from './schema';\n\nexport default class Model extends MagicObject {\n\n    public static schema: Schema;\n\n    public static<T extends typeof Model>(): T;\n    public static<T extends typeof Model, K extends keyof T>(property: K): T[K];\n    public static<T extends typeof Model, K extends keyof T>(property?: K): T | T[K] {\n        return super.static<T, K>(property as K);\n    }\n\n    declare public url?: string;\n    private __attributes: Record<string, unknown>;\n\n    public constructor(attributes: Record<string, unknown> = {}) {\n        super();\n\n        if (this.static().isConjuring()) {\n            this.__attributes = {};\n\n            return;\n        }\n\n        this.__attributes = this.static().schema.fields.parse(attributes);\n    }\n\n    public getAttributes(): Record<string, unknown> {\n        return this.__attributes;\n    }\n\n    public async toJsonLD(): Promise<JsonLD> {\n        return quadsToJsonLD(serializeToRDF(this));\n    }\n\n    public async toTurtle(): Promise<string> {\n        return quadsToTurtle(serializeToRDF(this));\n    }\n\n    protected __get(property: string): unknown {\n        return this.__attributes[property];\n    }\n\n}\n","import { object } from 'zod';\nimport { RDFNamedNode, expandIRI } from '@noeldemartin/solid-utils';\nimport type { Constructor } from '@noeldemartin/utils';\nimport type { ZodObject, ZodType, z } from 'zod';\nimport type { NamedNode } from '@rdfjs/types';\n\nimport Model from './Model';\n\nexport type Schema<T extends SchemaFields = SchemaFields> = {\n    fields: ZodObject<T>;\n    rdfContext: { default: string } & Record<string, string>;\n    rdfClasses: NamedNode[];\n    rdfDefaultResourceHash: string;\n    rdfFieldProperties: Record<string, NamedNode>;\n};\nexport type SchemaModel<T extends SchemaFields> = typeof Model & Constructor<z.infer<ZodObject<T>>>;\nexport type SchemaFields = Record<string, ZodType>;\n\nexport interface SchemaConfig<T extends SchemaFields> {\n    crdts?: boolean;\n    rdfContext?: string;\n    rdfClass?: string;\n    rdfDefaultResourceHash?: string;\n    fields: T;\n    relations?: Record<string, unknown>;\n}\n\nexport function defineSchema<T extends SchemaFields>(config: SchemaConfig<T>): SchemaModel<T> {\n    const rdfContext = config.rdfContext ? { default: config.rdfContext } : { default: 'solid' };\n    const { default: defaultPrefix, ...extraContext } = rdfContext;\n\n    return class extends Model {\n\n        public static schema = {\n            fields: object(config.fields) as unknown as ZodObject,\n            rdfContext,\n            rdfDefaultResourceHash: config.rdfDefaultResourceHash ?? 'it',\n            rdfClasses: config.rdfClass\n                ? [\n                    new RDFNamedNode(\n                        expandIRI(config.rdfClass, {\n                            defaultPrefix,\n                            extraContext,\n                        }),\n                    ),\n                ]\n                : [],\n            rdfFieldProperties: Object.fromEntries(\n                Object.entries(config.fields).map(([field, definition]) => [\n                    field,\n                    new RDFNamedNode(\n                        expandIRI(definition.rdfProperty() ?? field, {\n                            defaultPrefix,\n                            extraContext,\n                        }),\n                    ),\n                ]),\n            ),\n        };\n    \n    } as SchemaModel<T>;\n}\n","import { ZodDefault, ZodOptional } from 'zod';\nimport type { ZodType } from 'zod';\n\nfunction getDeepMeta<T extends keyof CustomMeta>(type: ZodType, key: T): CustomMeta[T] | undefined {\n    const meta = type.meta();\n\n    if (meta && key in meta) {\n        return meta[key];\n    }\n\n    if (type instanceof ZodDefault) {\n        return getDeepMeta(type.def.innerType as ZodType, key);\n    }\n\n    if (type instanceof ZodOptional) {\n        return getDeepMeta(type.def.innerType as ZodType, key);\n    }\n\n    return undefined;\n}\n\nexport interface CustomMeta {\n    rdfProperty?: string;\n}\n\nexport function rdfProperty<T extends ZodType>(this: T): string | undefined;\nexport function rdfProperty<T extends ZodType>(this: T, value: string): T;\nexport function rdfProperty<T extends ZodType>(this: T, value?: string): T | string | undefined {\n    if (typeof value !== 'string') {\n        return getDeepMeta(this, 'rdfProperty');\n    }\n\n    return this.meta({ rdfProperty: value });\n}\n\ndeclare module 'zod' {\n    interface GlobalMeta extends CustomMeta {}\n}\n","// This folder is used to extend Zod's native functionality with Soukai features by patching the prototypes\n// of core classes. This may seem like an anti-pattern, but it's actually been recommended by the author of Zod.\n//\n// See https://github.com/colinhacks/zod/pull/3445#issuecomment-2091463120\n\nimport { z } from 'zod';\nimport * as coreExtensions from './extensions/core';\n\nexport type ZodCoreExtensions = typeof coreExtensions;\n\nexport function patchZod(): void {\n    for (const [method, implementation] of Object.entries(coreExtensions)) {\n        z.ZodType.prototype[method] = implementation;\n    }\n}\n\ndeclare module 'zod' {\n    interface ZodType extends ZodCoreExtensions {}\n}\n"],"names":["RDF_TYPE","expandIRI","getFinalType","type","ZodOptional","ZodDefault","castValue","value","finalType","ZodArray","item","ZodURL","RDFNamedNode","RDFLiteral","serializeToRDF","model","fields","rdfDefaultResourceHash","rdfClasses","rdfFieldProperties","subject","statements","rdfClass","RDFQuad","field","object","Model","MagicObject","attributes","__publicField","property","quadsToJsonLD","quadsToTurtle","defineSchema","config","rdfContext","defaultPrefix","extraContext","_a","definition","getDeepMeta","key","meta","rdfProperty","patchZod","method","implementation","coreExtensions","z"],"mappings":"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"}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "soukai-bis",
+    "version": "0.0.0",
+    "type": "module",
+    "sideEffects": false,
+    "exports": {
+        "types": "./dist/soukai-bis.d.ts",
+        "default": "./dist/soukai-bis.js"
+    },
+    "files": [
+        "src",
+        "dist"
+    ],
+    "license": "MIT",
+    "author": "Noel De Martin",
+    "repository": "github:NoelDeMartin/soukai",
+    "scripts": {
+        "build": "vite build",
+        "lint": "noeldemartin-lint src",
+        "test": "vitest --run",
+        "test:ci": "vitest --run --reporter verbose --retry=3",
+        "verify": "noeldemartin-verify"
+    },
+    "dependencies": {
+        "@noeldemartin/solid-utils": "next",
+        "@noeldemartin/utils": "next",
+        "zod": "^4.3.4"
+    },
+    "devDependencies": {
+        "@arethetypeswrong/cli": "catalog:",
+        "@noeldemartin/scripts": "catalog:",
+        "@rdfjs/types": "catalog:",
+        "eslint": "catalog:",
+        "publint": "catalog:"
+    },
+    "eslintConfig": {
+        "extends": [
+            "@noeldemartin/eslint-config-typescript"
+        ]
+    }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './models';
+export * from './zod';

package/src/models/Model.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import { ZodError } from 'zod';
+
+import User from 'soukai-bis/testing/stubs/User';
+
+describe('Model', () => {
+
+    it('creates instances', () => {
+        const user = new User({ name: 'John Doe' });
+
+        expect(user.name).toEqual('John Doe');
+        expectTypeOf(user).toExtend<{ name: string; email?: string; age?: number; friendUrls: string[] }>();
+    });
+
+    it('validates attributes in constructor', () => {
+        expect(() => new User({ name: 'John Doe', email: 'invalid-email' })).toThrow(ZodError);
+    });
+
+    it('serializes to JsonLD', async () => {
+        const user = new User({ name: 'John Doe', friendUrls: ['https://example.pod/alice#me'] });
+
+        expect(await user.toJsonLD()).toEqualJsonLD({
+            '@context': 'http://xmlns.com/foaf/0.1/',
+            '@id': '#it',
+            '@type': 'Person',
+            'name': 'John Doe',
+            'knows': [{ '@id': 'https://example.pod/alice#me' }],
+        });
+    });
+
+    it('serializes to Turtle', async () => {
+        const user = new User({ name: 'John Doe', friendUrls: ['https://example.pod/alice#me'] });
+
+        expect(await user.toTurtle()).toEqualTurtle(`
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#it>
+                a foaf:Person ;
+                foaf:name "John Doe" ;
+                foaf:knows <https://example.pod/alice#me> .
+        `);
+    });
+
+});

package/src/models/Model.ts

@@ -0,0 +1,49 @@
+import { MagicObject } from '@noeldemartin/utils';
+import { quadsToJsonLD, quadsToTurtle } from '@noeldemartin/solid-utils';
+import type { JsonLD } from '@noeldemartin/solid-utils';
+
+import { serializeToRDF } from './concerns/serializes-to-rdf';
+import type { Schema } from './schema';
+
+export default class Model extends MagicObject {
+
+    public static schema: Schema;
+
+    public static<T extends typeof Model>(): T;
+    public static<T extends typeof Model, K extends keyof T>(property: K): T[K];
+    public static<T extends typeof Model, K extends keyof T>(property?: K): T | T[K] {
+        return super.static<T, K>(property as K);
+    }
+
+    declare public url?: string;
+    private __attributes: Record<string, unknown>;
+
+    public constructor(attributes: Record<string, unknown> = {}) {
+        super();
+
+        if (this.static().isConjuring()) {
+            this.__attributes = {};
+
+            return;
+        }
+
+        this.__attributes = this.static().schema.fields.parse(attributes);
+    }
+
+    public getAttributes(): Record<string, unknown> {
+        return this.__attributes;
+    }
+
+    public async toJsonLD(): Promise<JsonLD> {
+        return quadsToJsonLD(serializeToRDF(this));
+    }
+
+    public async toTurtle(): Promise<string> {
+        return quadsToTurtle(serializeToRDF(this));
+    }
+
+    protected __get(property: string): unknown {
+        return this.__attributes[property];
+    }
+
+}

package/src/models/concerns/serializes-to-rdf.ts

@@ -0,0 +1,53 @@
+import { ZodArray, ZodDefault, ZodOptional, ZodURL } from 'zod';
+import { RDFLiteral, RDFNamedNode, RDFQuad } from '@noeldemartin/solid-utils';
+import type { Quad, Quad_Object } from '@rdfjs/types';
+import type { SomeType } from 'zod/v4/core';
+
+import { RDF_TYPE } from 'soukai-bis/models/constants';
+import type Model from 'soukai-bis/models/Model';
+
+function getFinalType(type: SomeType): SomeType {
+    if (type instanceof ZodOptional) {
+        return getFinalType(type.def.innerType);
+    }
+
+    if (type instanceof ZodDefault) {
+        return getFinalType(type.def.innerType);
+    }
+
+    return type;
+}
+
+function castValue(value: unknown, type: SomeType): Quad_Object[] {
+    const finalType = getFinalType(type);
+
+    if (finalType instanceof ZodArray) {
+        const arrayValue = Array.isArray(value) ? value : value === null || value === undefined ? [] : [value];
+
+        return arrayValue.flatMap((item) => castValue(item, finalType.def.element));
+    }
+
+    if (finalType instanceof ZodURL) {
+        return [new RDFNamedNode(String(value))];
+    }
+
+    return [new RDFLiteral(String(value))];
+}
+
+export function serializeToRDF(model: Model): Quad[] {
+    const { fields, rdfDefaultResourceHash, rdfClasses, rdfFieldProperties } = model.static().schema;
+    const subject = new RDFNamedNode(model.url ?? `#${rdfDefaultResourceHash}`);
+    const statements: Quad[] = [];
+
+    for (const rdfClass of rdfClasses) {
+        statements.push(new RDFQuad(subject, RDF_TYPE, rdfClass));
+    }
+
+    for (const [field, value] of Object.entries(model.getAttributes())) {
+        for (const object of castValue(value, fields.def.shape[field])) {
+            statements.push(new RDFQuad(subject, rdfFieldProperties[field], object));
+        }
+    }
+
+    return statements;
+}

package/src/models/constants.ts

@@ -0,0 +1,3 @@
+import { expandIRI } from '@noeldemartin/solid-utils';
+
+export const RDF_TYPE = expandIRI('rdf:type');

package/src/models/index.ts

@@ -0,0 +1,3 @@
+export * from './schema';
+export * from './Model';
+export { default as Model } from './Model';

package/src/models/schema.ts

@@ -0,0 +1,62 @@
+import { object } from 'zod';
+import { RDFNamedNode, expandIRI } from '@noeldemartin/solid-utils';
+import type { Constructor } from '@noeldemartin/utils';
+import type { ZodObject, ZodType, z } from 'zod';
+import type { NamedNode } from '@rdfjs/types';
+
+import Model from './Model';
+
+export type Schema<T extends SchemaFields = SchemaFields> = {
+    fields: ZodObject<T>;
+    rdfContext: { default: string } & Record<string, string>;
+    rdfClasses: NamedNode[];
+    rdfDefaultResourceHash: string;
+    rdfFieldProperties: Record<string, NamedNode>;
+};
+export type SchemaModel<T extends SchemaFields> = typeof Model & Constructor<z.infer<ZodObject<T>>>;
+export type SchemaFields = Record<string, ZodType>;
+
+export interface SchemaConfig<T extends SchemaFields> {
+    crdts?: boolean;
+    rdfContext?: string;
+    rdfClass?: string;
+    rdfDefaultResourceHash?: string;
+    fields: T;
+    relations?: Record<string, unknown>;
+}
+
+export function defineSchema<T extends SchemaFields>(config: SchemaConfig<T>): SchemaModel<T> {
+    const rdfContext = config.rdfContext ? { default: config.rdfContext } : { default: 'solid' };
+    const { default: defaultPrefix, ...extraContext } = rdfContext;
+
+    return class extends Model {
+
+        public static schema = {
+            fields: object(config.fields) as unknown as ZodObject,
+            rdfContext,
+            rdfDefaultResourceHash: config.rdfDefaultResourceHash ?? 'it',
+            rdfClasses: config.rdfClass
+                ? [
+                    new RDFNamedNode(
+                        expandIRI(config.rdfClass, {
+                            defaultPrefix,
+                            extraContext,
+                        }),
+                    ),
+                ]
+                : [],
+            rdfFieldProperties: Object.fromEntries(
+                Object.entries(config.fields).map(([field, definition]) => [
+                    field,
+                    new RDFNamedNode(
+                        expandIRI(definition.rdfProperty() ?? field, {
+                            defaultPrefix,
+                            extraContext,
+                        }),
+                    ),
+                ]),
+            ),
+        };
+    
+    } as SchemaModel<T>;
+}

package/src/testing/setup.ts

@@ -0,0 +1,5 @@
+import { installVitestSolidMatchers } from '@noeldemartin/solid-utils/vitest';
+import { patchZod } from 'soukai-bis/zod';
+
+patchZod();
+installVitestSolidMatchers();

package/src/testing/stubs/User.schema.ts

@@ -0,0 +1,14 @@
+import { defineSchema } from 'soukai-bis/models';
+import { array, email, number, string, url } from 'zod';
+
+export default defineSchema({
+    crdts: true,
+    rdfContext: 'http://xmlns.com/foaf/0.1/',
+    rdfClass: 'Person',
+    fields: {
+        name: string(),
+        email: email().optional(),
+        age: number().optional(),
+        friendUrls: array(url()).rdfProperty('knows').default([]),
+    },
+});

package/src/testing/stubs/User.ts

@@ -0,0 +1,3 @@
+import Model from './User.schema';
+
+export default class User extends Model {}

package/src/zod/extensions/core.ts

@@ -0,0 +1,38 @@
+import { ZodDefault, ZodOptional } from 'zod';
+import type { ZodType } from 'zod';
+
+function getDeepMeta<T extends keyof CustomMeta>(type: ZodType, key: T): CustomMeta[T] | undefined {
+    const meta = type.meta();
+
+    if (meta && key in meta) {
+        return meta[key];
+    }
+
+    if (type instanceof ZodDefault) {
+        return getDeepMeta(type.def.innerType as ZodType, key);
+    }
+
+    if (type instanceof ZodOptional) {
+        return getDeepMeta(type.def.innerType as ZodType, key);
+    }
+
+    return undefined;
+}
+
+export interface CustomMeta {
+    rdfProperty?: string;
+}
+
+export function rdfProperty<T extends ZodType>(this: T): string | undefined;
+export function rdfProperty<T extends ZodType>(this: T, value: string): T;
+export function rdfProperty<T extends ZodType>(this: T, value?: string): T | string | undefined {
+    if (typeof value !== 'string') {
+        return getDeepMeta(this, 'rdfProperty');
+    }
+
+    return this.meta({ rdfProperty: value });
+}
+
+declare module 'zod' {
+    interface GlobalMeta extends CustomMeta {}
+}

package/src/zod/index.ts

@@ -0,0 +1,19 @@
+// This folder is used to extend Zod's native functionality with Soukai features by patching the prototypes
+// of core classes. This may seem like an anti-pattern, but it's actually been recommended by the author of Zod.
+//
+// See https://github.com/colinhacks/zod/pull/3445#issuecomment-2091463120
+
+import { z } from 'zod';
+import * as coreExtensions from './extensions/core';
+
+export type ZodCoreExtensions = typeof coreExtensions;
+
+export function patchZod(): void {
+    for (const [method, implementation] of Object.entries(coreExtensions)) {
+        z.ZodType.prototype[method] = implementation;
+    }
+}
+
+declare module 'zod' {
+    interface ZodType extends ZodCoreExtensions {}
+}