@lssm/lib.schema 0.0.0-canary-20251217062943 → 0.0.0-canary-20251217072406

package/dist/EnumType.js

@@ -1 +1,56 @@
-import*as e from"zod";import{GraphQLEnumType as t}from"graphql";var n=class{name;values;gqlEnum;constructor(e,n){this.name=e,this.values=n,this.gqlEnum=new t({name:this.name,values:Object.fromEntries(n.map(e=>[e,{value:e}]))})}getName(){return this.name}getEnumValues(){return this.values}getPothos(){return this.gqlEnum}getZod(){return e.enum(this.values)}getJson(){return{type:`string`,enum:this.values}}getJsonSchema(){return this.getJson()}};const r=(e,t)=>new n(e,t);export{n as EnumType,r as defineEnum};
+import * as z from "zod";
+import { GraphQLEnumType } from "graphql";
+
+//#region src/EnumType.ts
+/**
+* Strongly-typed string enum wrapper with one source of truth for zod, GraphQL, and JSON Schema.
+*/
+var EnumType = class {
+	name;
+	values;
+	gqlEnum;
+	constructor(name, values) {
+		this.name = name;
+		this.values = values;
+		this.gqlEnum = new GraphQLEnumType({
+			name: this.name,
+			values: Object.fromEntries(values.map((v) => [v, { value: v }]))
+		});
+	}
+	/** Enum type name (used by GraphQL and JSON Schema). */
+	getName() {
+		return this.name;
+	}
+	/** Returns the literal tuple of allowed values. */
+	getEnumValues() {
+		return this.values;
+	}
+	/** GraphQL enum instance suitable for Pothos or vanilla GraphQL schemas. */
+	getPothos() {
+		return this.gqlEnum;
+	}
+	/** zod schema representing this enum. */
+	getZod() {
+		return z.enum(this.values);
+	}
+	/** Minimal JSON representation (alias of getJsonSchema). */
+	getJson() {
+		return {
+			type: "string",
+			enum: this.values
+		};
+	}
+	/** JSON Schema for this enum. */
+	getJsonSchema() {
+		return this.getJson();
+	}
+};
+/**
+* Helper to define an EnumType.
+* @param name Display/type name used across GraphQL and JSON Schema
+* @param values Literal tuple of allowed string values (at least one)
+*/
+const defineEnum = (name, values) => new EnumType(name, values);
+
+//#endregion
+export { EnumType, defineEnum };

package/dist/FieldType.js

@@ -1 +1,49 @@
-import"zod";import{GraphQLScalarType as e}from"graphql";var t=class extends e{zodSchema;jsonSchemaDef;constructor(e){super(e),this.zodSchema=e.zod,this.jsonSchemaDef=e.jsonSchema}getZod(){return this.zodSchema}getPothos(){return this}getJson(){return typeof this.jsonSchemaDef==`function`?this.jsonSchemaDef():this.jsonSchemaDef}getJsonSchemaDef(){return this.jsonSchemaDef}getJsonSchema(){let e=t=>{let n=typeof t==`function`?t():t;if(Array.isArray(n))return n.map(t=>e(t));if(n&&typeof n==`object`){let t={};for(let[r,i]of Object.entries(n))t[r]=e(i);return t}return n};return e(this.getJson())}};export{t as FieldType};
+import "zod";
+import { GraphQLScalarType } from "graphql";
+
+//#region src/FieldType.ts
+/**
+* GraphQL scalar wrapper that carries zod and JSON Schema metadata.
+*
+* TInternal is the runtime representation; TExternal is the GraphQL output.
+*/
+var FieldType = class extends GraphQLScalarType {
+	zodSchema;
+	jsonSchemaDef;
+	constructor(config) {
+		super(config);
+		this.zodSchema = config.zod;
+		this.jsonSchemaDef = config.jsonSchema;
+	}
+	/** Return the attached zod schema for validation. */
+	getZod() {
+		return this.zodSchema;
+	}
+	/** GraphQL scalar instance usable by Pothos or vanilla GraphQL. */
+	getPothos() {
+		return this;
+	}
+	/** Return the JSON Schema (evaluates factory if provided). */
+	getJson() {
+		return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
+	}
+	getJsonSchemaDef() {
+		return this.jsonSchemaDef;
+	}
+	getJsonSchema() {
+		const deepResolve = (v) => {
+			const value = typeof v === "function" ? v() : v;
+			if (Array.isArray(value)) return value.map((item) => deepResolve(item));
+			if (value && typeof value === "object") {
+				const obj = {};
+				for (const [k, val] of Object.entries(value)) obj[k] = deepResolve(val);
+				return obj;
+			}
+			return value;
+		};
+		return deepResolve(this.getJson());
+	}
+};
+
+//#endregion
+export { FieldType };

package/dist/ScalarTypeEnum.js

@@ -1 +1,236 @@
-import{FieldType as e}from"./FieldType.js";import*as t from"zod";import{Kind as n}from"graphql";const r=/^[A-Za-z]{2}(?:-[A-Za-z0-9]{2,8})*$/,i=/^(?:UTC|[A-Za-z_]+\/[A-Za-z_]+)$/,a=/^[+]?\d[\d\s().-]{3,}$/,o=/^[A-Z]{3}$/,s=/^[A-Z]{2}$/,c=-180,l={String_unsecure:()=>new e({name:`String_unsecure`,description:`Unvalidated string scalar`,zod:t.string(),parseValue:e=>t.string().parse(e),serialize:e=>String(e),parseLiteral:e=>{if(e.kind!==n.STRING)throw TypeError(`Invalid literal`);return e.value},jsonSchema:{type:`string`}}),Int_unsecure:()=>new e({name:`Int_unsecure`,description:`Unvalidated integer scalar`,zod:t.number().int(),parseValue:e=>{let n=typeof e==`number`?e:Number(e);return t.number().int().parse(n)},serialize:e=>Math.trunc(typeof e==`number`?e:Number(e)),parseLiteral:e=>{if(e.kind!==n.INT)throw TypeError(`Invalid literal`);return Number(e.value)},jsonSchema:{type:`integer`}}),Float_unsecure:()=>new e({name:`Float_unsecure`,description:`Unvalidated float scalar`,zod:t.number(),parseValue:e=>{let n=typeof e==`number`?e:Number(e);return t.number().parse(n)},serialize:e=>Number(e),parseLiteral:e=>{if(e.kind!==n.FLOAT&&e.kind!==n.INT)throw TypeError(`Invalid literal`);return Number(e.value)},jsonSchema:{type:`number`}}),Boolean:()=>new e({name:`Boolean`,description:`Unvalidated boolean scalar`,zod:t.boolean(),parseValue:e=>t.coerce.boolean().parse(e),serialize:e=>!!e,parseLiteral:e=>{if(e.kind!==n.BOOLEAN)throw TypeError(`Invalid literal`);return e.value},jsonSchema:{type:`boolean`}}),ID:()=>new e({name:`ID`,description:`Unvalidated id scalar`,zod:t.string(),parseValue:e=>t.string().parse(e),serialize:e=>String(e),parseLiteral:e=>{if(e.kind!==n.STRING)throw TypeError(`Invalid literal`);return e.value},jsonSchema:{type:`string`}}),JSON:()=>new e({name:`JSON`,zod:t.any(),parseValue:e=>e,serialize:e=>e,jsonSchema:{}}),JSONObject:()=>new e({name:`JSONObject`,zod:t.record(t.string(),t.any()),parseValue:e=>t.record(t.string(),t.any()).parse(e),serialize:e=>e??{},jsonSchema:{type:`object`}}),Date:()=>new e({name:`Date`,zod:t.date(),parseValue:e=>e instanceof Date?e:new Date(String(e)),serialize:e=>e instanceof Date?e.toISOString().split(`T`)[0]:String(e),jsonSchema:{type:`string`,format:`date`}}),DateTime:()=>new e({name:`DateTime`,zod:t.date(),parseValue:e=>e instanceof Date?e:new Date(String(e)),serialize:e=>e instanceof Date?e.toISOString():String(e),jsonSchema:{type:`string`,format:`date-time`}}),Time:()=>new e({name:`Time`,zod:t.string().regex(/^\d{2}:\d{2}(:\d{2})?$/),parseValue:e=>t.string().regex(/^\d{2}:\d{2}(:\d{2})?$/).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,pattern:`^\\d{2}:\\d{2}(:\\d{2})?$`}}),EmailAddress:()=>new e({name:`EmailAddress`,zod:t.string().email(),parseValue:e=>t.string().email().parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,format:`email`}}),URL:()=>new e({name:`URL`,zod:t.string().url(),parseValue:e=>t.string().url().parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,format:`uri`}}),PhoneNumber:()=>new e({name:`PhoneNumber`,zod:t.string().regex(a),parseValue:e=>t.string().regex(a).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,pattern:a.source}}),NonEmptyString:()=>new e({name:`NonEmptyString`,zod:t.string().min(1),parseValue:e=>t.string().min(1).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,minLength:1}}),Locale:()=>new e({name:`Locale`,zod:t.string().regex(r),parseValue:e=>t.string().regex(r).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,pattern:r.source}}),TimeZone:()=>new e({name:`TimeZone`,zod:t.string().regex(i),parseValue:e=>t.string().regex(i).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,pattern:i.source}}),Latitude:()=>new e({name:`Latitude`,zod:t.number().min(-90).max(90),parseValue:e=>t.coerce.number().min(-90).max(90).parse(e),serialize:e=>Number(e),jsonSchema:{type:`number`,minimum:-90,maximum:90}}),Longitude:()=>new e({name:`Longitude`,zod:t.number().min(c).max(180),parseValue:e=>t.coerce.number().min(c).max(180).parse(e),serialize:e=>Number(e),jsonSchema:{type:`number`,minimum:c,maximum:180}}),Currency:()=>new e({name:`Currency`,zod:t.string().regex(o),parseValue:e=>t.string().regex(o).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,pattern:o.source}}),CountryCode:()=>new e({name:`CountryCode`,zod:t.string().regex(s),parseValue:e=>t.string().regex(s).parse(e),serialize:e=>String(e),jsonSchema:{type:`string`,pattern:s.source}})};export{l as ScalarTypeEnum};
+import { FieldType } from "./FieldType.js";
+import * as z from "zod";
+import { Kind } from "graphql";
+
+//#region src/ScalarTypeEnum.ts
+const localeRegex = /^[A-Za-z]{2}(?:-[A-Za-z0-9]{2,8})*$/;
+const timezoneRegex = /^(?:UTC|[A-Za-z_]+\/[A-Za-z_]+)$/;
+const phoneRegex = /^[+]?\d[\d\s().-]{3,}$/;
+const currencyRegex = /^[A-Z]{3}$/;
+const countryRegex = /^[A-Z]{2}$/;
+const latMin = -90;
+const latMax = 90;
+const lonMin = -180;
+const lonMax = 180;
+/**
+* Factory functions for common scalar FieldTypes with zod/GraphQL/JSON Schema.
+*/
+const ScalarTypeEnum = {
+	String_unsecure: () => new FieldType({
+		name: "String_unsecure",
+		description: "Unvalidated string scalar",
+		zod: z.string(),
+		parseValue: (v) => z.string().parse(v),
+		serialize: (v) => String(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.STRING) throw new TypeError("Invalid literal");
+			return ast.value;
+		},
+		jsonSchema: { type: "string" }
+	}),
+	Int_unsecure: () => new FieldType({
+		name: "Int_unsecure",
+		description: "Unvalidated integer scalar",
+		zod: z.number().int(),
+		parseValue: (v) => {
+			const num = typeof v === "number" ? v : Number(v);
+			return z.number().int().parse(num);
+		},
+		serialize: (v) => Math.trunc(typeof v === "number" ? v : Number(v)),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.INT) throw new TypeError("Invalid literal");
+			return Number(ast.value);
+		},
+		jsonSchema: { type: "integer" }
+	}),
+	Float_unsecure: () => new FieldType({
+		name: "Float_unsecure",
+		description: "Unvalidated float scalar",
+		zod: z.number(),
+		parseValue: (v) => {
+			const num = typeof v === "number" ? v : Number(v);
+			return z.number().parse(num);
+		},
+		serialize: (v) => Number(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.FLOAT && ast.kind !== Kind.INT) throw new TypeError("Invalid literal");
+			return Number(ast.value);
+		},
+		jsonSchema: { type: "number" }
+	}),
+	Boolean: () => new FieldType({
+		name: "Boolean",
+		description: "Unvalidated boolean scalar",
+		zod: z.boolean(),
+		parseValue: (v) => z.coerce.boolean().parse(v),
+		serialize: (v) => Boolean(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.BOOLEAN) throw new TypeError("Invalid literal");
+			return ast.value;
+		},
+		jsonSchema: { type: "boolean" }
+	}),
+	ID: () => new FieldType({
+		name: "ID",
+		description: "Unvalidated id scalar",
+		zod: z.string(),
+		parseValue: (v) => z.string().parse(v),
+		serialize: (v) => String(v),
+		parseLiteral: (ast) => {
+			if (ast.kind !== Kind.STRING) throw new TypeError("Invalid literal");
+			return ast.value;
+		},
+		jsonSchema: { type: "string" }
+	}),
+	JSON: () => new FieldType({
+		name: "JSON",
+		zod: z.any(),
+		parseValue: (v) => v,
+		serialize: (v) => v,
+		jsonSchema: {}
+	}),
+	JSONObject: () => new FieldType({
+		name: "JSONObject",
+		zod: z.record(z.string(), z.any()),
+		parseValue: (v) => z.record(z.string(), z.any()).parse(v),
+		serialize: (v) => v ?? {},
+		jsonSchema: { type: "object" }
+	}),
+	Date: () => new FieldType({
+		name: "Date",
+		zod: z.date(),
+		parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
+		serialize: (v) => v instanceof Date ? v.toISOString().split("T")[0] : String(v),
+		jsonSchema: {
+			type: "string",
+			format: "date"
+		}
+	}),
+	DateTime: () => new FieldType({
+		name: "DateTime",
+		zod: z.date(),
+		parseValue: (v) => v instanceof Date ? v : new Date(String(v)),
+		serialize: (v) => {
+			return v instanceof Date ? v.toISOString() : String(v);
+		},
+		jsonSchema: {
+			type: "string",
+			format: "date-time"
+		}
+	}),
+	Time: () => new FieldType({
+		name: "Time",
+		zod: z.string().regex(/^\d{2}:\d{2}(:\d{2})?$/),
+		parseValue: (v) => z.string().regex(/^\d{2}:\d{2}(:\d{2})?$/).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: "^\\d{2}:\\d{2}(:\\d{2})?$"
+		}
+	}),
+	EmailAddress: () => new FieldType({
+		name: "EmailAddress",
+		zod: z.string().email(),
+		parseValue: (v) => z.string().email().parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			format: "email"
+		}
+	}),
+	URL: () => new FieldType({
+		name: "URL",
+		zod: z.string().url(),
+		parseValue: (v) => z.string().url().parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			format: "uri"
+		}
+	}),
+	PhoneNumber: () => new FieldType({
+		name: "PhoneNumber",
+		zod: z.string().regex(phoneRegex),
+		parseValue: (v) => z.string().regex(phoneRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: phoneRegex.source
+		}
+	}),
+	NonEmptyString: () => new FieldType({
+		name: "NonEmptyString",
+		zod: z.string().min(1),
+		parseValue: (v) => z.string().min(1).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			minLength: 1
+		}
+	}),
+	Locale: () => new FieldType({
+		name: "Locale",
+		zod: z.string().regex(localeRegex),
+		parseValue: (v) => z.string().regex(localeRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: localeRegex.source
+		}
+	}),
+	TimeZone: () => new FieldType({
+		name: "TimeZone",
+		zod: z.string().regex(timezoneRegex),
+		parseValue: (v) => z.string().regex(timezoneRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: timezoneRegex.source
+		}
+	}),
+	Latitude: () => new FieldType({
+		name: "Latitude",
+		zod: z.number().min(latMin).max(latMax),
+		parseValue: (v) => z.coerce.number().min(latMin).max(latMax).parse(v),
+		serialize: (v) => Number(v),
+		jsonSchema: {
+			type: "number",
+			minimum: latMin,
+			maximum: latMax
+		}
+	}),
+	Longitude: () => new FieldType({
+		name: "Longitude",
+		zod: z.number().min(lonMin).max(lonMax),
+		parseValue: (v) => z.coerce.number().min(lonMin).max(lonMax).parse(v),
+		serialize: (v) => Number(v),
+		jsonSchema: {
+			type: "number",
+			minimum: lonMin,
+			maximum: lonMax
+		}
+	}),
+	Currency: () => new FieldType({
+		name: "Currency",
+		zod: z.string().regex(currencyRegex),
+		parseValue: (v) => z.string().regex(currencyRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: currencyRegex.source
+		}
+	}),
+	CountryCode: () => new FieldType({
+		name: "CountryCode",
+		zod: z.string().regex(countryRegex),
+		parseValue: (v) => z.string().regex(countryRegex).parse(v),
+		serialize: (v) => String(v),
+		jsonSchema: {
+			type: "string",
+			pattern: countryRegex.source
+		}
+	})
+};
+
+//#endregion
+export { ScalarTypeEnum };

package/dist/SchemaModel.js

@@ -1 +1,39 @@
-import"./EnumType.js";import"./FieldType.js";import*as e from"zod";var t=class{constructor(e){this.config=e}getZod(){let t=Object.entries(this.config.fields).reduce((t,[n,r])=>{let i=r.type.getZod(),a=r.isArray?e.array(i):i;return t[n]=r.isOptional?a.optional():a,t},{});return e.object(t)}getPothosInput(){return this.config.name}};const n=e=>new t(e);export{t as SchemaModel,n as defineSchemaModel};
+import "./EnumType.js";
+import "./FieldType.js";
+import * as z from "zod";
+
+//#region src/SchemaModel.ts
+/**
+* Named object model built from FieldType/EnumType/SchemaModel fields.
+* Provides zod and GraphQL input helpers, and supports arrays/optional fields.
+*/
+var SchemaModel = class {
+	constructor(config) {
+		this.config = config;
+	}
+	/**
+	* Build a typed ZodObject from the model fields, preserving each field's
+	* Zod schema and optionality at the type level when possible.
+	*/
+	getZod() {
+		const shape = Object.entries(this.config.fields).reduce((acc, [key, def]) => {
+			const base = def.type.getZod();
+			const withArray = def.isArray ? z.array(base) : base;
+			acc[key] = def.isOptional ? withArray.optional() : withArray;
+			return acc;
+		}, {});
+		return z.object(shape);
+	}
+	/** Input object name for GraphQL builder adapters. */
+	getPothosInput() {
+		return this.config.name;
+	}
+};
+/**
+* Helper to define a SchemaModel with type inference.
+* Equivalent to `new SchemaModel(config)` but with better ergonomics.
+*/
+const defineSchemaModel = (config) => new SchemaModel(config);
+
+//#endregion
+export { SchemaModel, defineSchemaModel };

package/dist/entity/defineEntity.js

@@ -1 +1,236 @@
-import*as e from"zod";function t(e){return e}function n(e){return e}const r={string(e){return{kind:`scalar`,type:`String`,...e}},int(e){return{kind:`scalar`,type:`Int`,...e}},float(e){return{kind:`scalar`,type:`Float`,...e}},boolean(e){return{kind:`scalar`,type:`Boolean`,...e}},dateTime(e){return{kind:`scalar`,type:`DateTime`,...e}},json(e){return{kind:`scalar`,type:`Json`,...e}},bigInt(e){return{kind:`scalar`,type:`BigInt`,...e}},decimal(e){return{kind:`scalar`,type:`Decimal`,...e}},bytes(e){return{kind:`scalar`,type:`Bytes`,...e}},id(e){return{kind:`scalar`,type:`String`,isId:!0,default:`cuid()`,...e}},uuid(e){return{kind:`scalar`,type:`String`,isId:!0,default:`uuid()`,...e}},autoIncrement(e){return{kind:`scalar`,type:`Int`,isId:!0,default:`autoincrement()`,...e}},createdAt(e){return{kind:`scalar`,type:`DateTime`,default:`now()`,...e}},updatedAt(e){return{kind:`scalar`,type:`DateTime`,updatedAt:!0,...e}},email(t){return{kind:`scalar`,type:`String`,zod:e.email(),...t}},url(t){return{kind:`scalar`,type:`String`,zod:e.url(),...t}},enum(e,t){return{kind:`enum`,enumName:e,...t}},inlineEnum(e,t,n){return{kind:`enum`,enumName:e,values:t,...n}},hasOne(e,t){return{kind:`relation`,type:`hasOne`,target:e,...t}},hasMany(e,t){return{kind:`relation`,type:`hasMany`,target:e,...t}},belongsTo(e,t,n,r){return{kind:`relation`,type:`belongsTo`,target:e,fields:t,references:n,...r}},foreignKey(e){return{kind:`scalar`,type:`String`,...e}}},i={on(e,t){return{fields:e,...t}},unique(e,t){return{fields:e,unique:!0,...t}},compound(e,t,n){return{fields:e,sort:t,...n}}};export{t as defineEntity,n as defineEntityEnum,r as field,i as index};
+import * as z from "zod";
+
+//#region src/entity/defineEntity.ts
+/**
+* Helper to define a database entity with full type safety.
+*
+* @example
+* ```typescript
+* const UserEntity = defineEntity({
+*   name: 'User',
+*   schema: 'lssm_sigil',
+*   description: 'A user of the platform.',
+*   fields: {
+*     id: field.id(),
+*     email: field.string({ isUnique: true, zod: z.string().email() }),
+*     name: field.string({ isOptional: true }),
+*     createdAt: field.createdAt(),
+*     updatedAt: field.updatedAt(),
+*     memberships: field.hasMany('Member'),
+*   },
+*   indexes: [{ fields: ['email'], unique: true }],
+* });
+* ```
+*/
+function defineEntity(spec) {
+	return spec;
+}
+/**
+* Helper to define an enum that can be shared across entities.
+*/
+function defineEntityEnum(def) {
+	return def;
+}
+/**
+* Field builder helpers for common field patterns.
+*/
+const field = {
+	string(opts) {
+		return {
+			kind: "scalar",
+			type: "String",
+			...opts
+		};
+	},
+	int(opts) {
+		return {
+			kind: "scalar",
+			type: "Int",
+			...opts
+		};
+	},
+	float(opts) {
+		return {
+			kind: "scalar",
+			type: "Float",
+			...opts
+		};
+	},
+	boolean(opts) {
+		return {
+			kind: "scalar",
+			type: "Boolean",
+			...opts
+		};
+	},
+	dateTime(opts) {
+		return {
+			kind: "scalar",
+			type: "DateTime",
+			...opts
+		};
+	},
+	json(opts) {
+		return {
+			kind: "scalar",
+			type: "Json",
+			...opts
+		};
+	},
+	bigInt(opts) {
+		return {
+			kind: "scalar",
+			type: "BigInt",
+			...opts
+		};
+	},
+	decimal(opts) {
+		return {
+			kind: "scalar",
+			type: "Decimal",
+			...opts
+		};
+	},
+	bytes(opts) {
+		return {
+			kind: "scalar",
+			type: "Bytes",
+			...opts
+		};
+	},
+	id(opts) {
+		return {
+			kind: "scalar",
+			type: "String",
+			isId: true,
+			default: "cuid()",
+			...opts
+		};
+	},
+	uuid(opts) {
+		return {
+			kind: "scalar",
+			type: "String",
+			isId: true,
+			default: "uuid()",
+			...opts
+		};
+	},
+	autoIncrement(opts) {
+		return {
+			kind: "scalar",
+			type: "Int",
+			isId: true,
+			default: "autoincrement()",
+			...opts
+		};
+	},
+	createdAt(opts) {
+		return {
+			kind: "scalar",
+			type: "DateTime",
+			default: "now()",
+			...opts
+		};
+	},
+	updatedAt(opts) {
+		return {
+			kind: "scalar",
+			type: "DateTime",
+			updatedAt: true,
+			...opts
+		};
+	},
+	email(opts) {
+		return {
+			kind: "scalar",
+			type: "String",
+			zod: z.email(),
+			...opts
+		};
+	},
+	url(opts) {
+		return {
+			kind: "scalar",
+			type: "String",
+			zod: z.url(),
+			...opts
+		};
+	},
+	enum(enumName, opts) {
+		return {
+			kind: "enum",
+			enumName,
+			...opts
+		};
+	},
+	inlineEnum(enumName, values, opts) {
+		return {
+			kind: "enum",
+			enumName,
+			values,
+			...opts
+		};
+	},
+	hasOne(target, opts) {
+		return {
+			kind: "relation",
+			type: "hasOne",
+			target,
+			...opts
+		};
+	},
+	hasMany(target, opts) {
+		return {
+			kind: "relation",
+			type: "hasMany",
+			target,
+			...opts
+		};
+	},
+	belongsTo(target, fields, references, opts) {
+		return {
+			kind: "relation",
+			type: "belongsTo",
+			target,
+			fields,
+			references,
+			...opts
+		};
+	},
+	foreignKey(opts) {
+		return {
+			kind: "scalar",
+			type: "String",
+			...opts
+		};
+	}
+};
+/**
+* Index builder helpers.
+*/
+const index = {
+	on(fields, opts) {
+		return {
+			fields,
+			...opts
+		};
+	},
+	unique(fields, opts) {
+		return {
+			fields,
+			unique: true,
+			...opts
+		};
+	},
+	compound(fields, sort, opts) {
+		return {
+			fields,
+			sort,
+			...opts
+		};
+	}
+};
+
+//#endregion
+export { defineEntity, defineEntityEnum, field, index };

package/dist/entity/generator.js

@@ -1,4 +1,217 @@
-function e(e,r={}){let{provider:i=`postgresql`,clientOutput:a=`../../src/generated/prisma`,includePothos:o=!0,pothosOutput:s=`../../src/generated/pothos-types.ts`}=r,c=[],l=new Set;e.forEach(e=>{e.schema&&l.add(e.schema)});let u=l.size>0?Array.from(l):[`public`];c.push(`datasource db {`),c.push(`  provider = "${i}"`),l.size>0&&c.push(`  schemas  = [${u.map(e=>`"${e}"`).join(`, `)}]`),c.push(`}`),c.push(``),c.push(`generator client {`),c.push(`  provider = "prisma-client"`),c.push(`  output   = "${a}"`),c.push(``),c.push(`  engineType             = "client"`),c.push(`  runtime                = "bun"`),c.push(`  moduleFormat           = "esm"`),c.push(`  generatedFileExtension = "ts"`),c.push(`  importFileExtension    = "ts"`),c.push(`}`),c.push(``),o&&(c.push(`generator pothos {`),c.push(`  provider          = "prisma-pothos-types"`),c.push(`  clientOutput      = "./prisma"`),c.push(`  output            = "${s}"`),c.push(`  generateDatamodel = true`),c.push(`  documentation     = false`),c.push(`}`),c.push(``));let d=new Map;return e.forEach(e=>{e.enums?.forEach(e=>{d.has(e.name)||d.set(e.name,e)}),Object.values(e.fields).forEach(t=>{t.kind===`enum`&&t.values&&!d.has(t.enumName)&&d.set(t.enumName,{name:t.enumName,values:t.values,schema:e.schema})})}),d.forEach(e=>{c.push(...t(e)),c.push(``)}),e.forEach(e=>{c.push(...n(e)),c.push(``)}),c.join(`
-`)}function t(e){let t=[];return e.description&&t.push(`/// ${e.description}`),t.push(`enum ${e.name} {`),e.values.forEach(e=>{t.push(`  ${e}`)}),t.push(``),e.schema&&t.push(`  @@schema("${e.schema}")`),t.push(`}`),t}function n(e){let t=[];return e.description&&t.push(`/// ${e.description}`),t.push(`model ${e.name} {`),Object.entries(e.fields).forEach(([e,n])=>{let i=r(e,n);n.description&&t.push(`  /// ${n.description}`),t.push(`  ${i}`)}),e.indexes&&e.indexes.length>0&&(t.push(``),e.indexes.forEach(e=>{t.push(`  ${s(e)}`)})),e.map&&t.push(`  @@map("${e.map}")`),e.schema&&t.push(`  @@schema("${e.schema}")`),t.push(`}`),t}function r(e,t){if(t.kind===`scalar`)return i(e,t);if(t.kind===`enum`)return a(e,t);if(t.kind===`relation`)return o(e,t);throw Error(`Unknown field kind: ${t.kind}`)}function i(e,t){let n=[e],r=t.type;t.isArray&&(r+=`[]`),t.isOptional&&(r+=`?`),n.push(r);let i=[];return t.isId&&i.push(`@id`),t.default!==void 0&&(typeof t.default==`string`&&t.default.includes(`(`)||typeof t.default==`boolean`||typeof t.default==`number`?i.push(`@default(${t.default})`):i.push(`@default("${t.default}")`)),t.updatedAt&&i.push(`@updatedAt`),t.isUnique&&i.push(`@unique`),t.map&&i.push(`@map("${t.map}")`),t.dbType&&i.push(`@db.${t.dbType}`),i.length>0&&n.push(i.join(` `)),n.join(` `)}function a(e,t){let n=[e],r=t.enumName;t.isArray&&(r+=`[]`),t.isOptional&&(r+=`?`),n.push(r);let i=[];return t.default!==void 0&&i.push(`@default(${t.default})`),t.isUnique&&i.push(`@unique`),t.map&&i.push(`@map("${t.map}")`),i.length>0&&n.push(i.join(` `)),n.join(` `)}function o(e,t){let n=[e],r=t.target;t.type===`hasMany`&&(r+=`[]`),t.type===`hasOne`&&(r+=`?`),n.push(r);let i=[];return t.name&&i.push(`name: "${t.name}"`),t.fields&&t.fields.length>0&&i.push(`fields: [${t.fields.join(`, `)}]`),t.references&&t.references.length>0&&i.push(`references: [${t.references.join(`, `)}]`),t.onDelete&&i.push(`onDelete: ${t.onDelete}`),t.onUpdate&&i.push(`onUpdate: ${t.onUpdate}`),i.length>0&&n.push(`@relation(${i.join(`, `)})`),n.join(` `)}function s(e){let t=e.fields.join(`, `),n=[];e.unique?n.push(`@@unique([${t}]`):n.push(`@@index([${t}]`);let r=[];return e.name&&r.push(`name: "${e.name}"`),e.type&&r.push(`type: ${e.type}`),r.length>0&&(n[0]+=`, ${r.join(`, `)}`),n[0]+=`)`,n.join(``)}function c(t,n={}){let r=[],i=new Map;return t.forEach(e=>{e.entities.forEach(t=>{r.push({...t,module:e.moduleId})}),e.enums?.forEach(e=>{i.has(e.name)||i.set(e.name,e)})}),r.length>0&&i.size>0&&(r[0]={...r[0],enums:[...r[0].enums??[],...i.values()]}),e(r,n)}function l(e){return n(e).join(`
-`)}function u(e){return t(e).join(`
-`)}export{c as composeModuleSchemas,l as generateEntityFragment,u as generateEnumFragment,e as generatePrismaSchema};
+//#region src/entity/generator.ts
+/**
+* Generate Prisma schema content from entity specifications.
+*/
+function generatePrismaSchema(entities, options = {}) {
+	const { provider = "postgresql", clientOutput = "../../src/generated/prisma", includePothos = true, pothosOutput = "../../src/generated/pothos-types.ts" } = options;
+	const lines = [];
+	const schemas = /* @__PURE__ */ new Set();
+	entities.forEach((entity) => {
+		if (entity.schema) schemas.add(entity.schema);
+	});
+	const schemaList = schemas.size > 0 ? Array.from(schemas) : ["public"];
+	lines.push("datasource db {");
+	lines.push(`  provider = "${provider}"`);
+	if (schemas.size > 0) lines.push(`  schemas  = [${schemaList.map((s) => `"${s}"`).join(", ")}]`);
+	lines.push("}");
+	lines.push("");
+	lines.push("generator client {");
+	lines.push("  provider = \"prisma-client\"");
+	lines.push(`  output   = "${clientOutput}"`);
+	lines.push("");
+	lines.push("  engineType             = \"client\"");
+	lines.push("  runtime                = \"bun\"");
+	lines.push("  moduleFormat           = \"esm\"");
+	lines.push("  generatedFileExtension = \"ts\"");
+	lines.push("  importFileExtension    = \"ts\"");
+	lines.push("}");
+	lines.push("");
+	if (includePothos) {
+		lines.push("generator pothos {");
+		lines.push("  provider          = \"prisma-pothos-types\"");
+		lines.push("  clientOutput      = \"./prisma\"");
+		lines.push(`  output            = "${pothosOutput}"`);
+		lines.push("  generateDatamodel = true");
+		lines.push("  documentation     = false");
+		lines.push("}");
+		lines.push("");
+	}
+	const enumMap = /* @__PURE__ */ new Map();
+	entities.forEach((entity) => {
+		entity.enums?.forEach((enumDef) => {
+			if (!enumMap.has(enumDef.name)) enumMap.set(enumDef.name, enumDef);
+		});
+		Object.values(entity.fields).forEach((field) => {
+			if (field.kind === "enum" && field.values && !enumMap.has(field.enumName)) enumMap.set(field.enumName, {
+				name: field.enumName,
+				values: field.values,
+				schema: entity.schema
+			});
+		});
+	});
+	enumMap.forEach((enumDef) => {
+		lines.push(...generateEnumBlock(enumDef));
+		lines.push("");
+	});
+	entities.forEach((entity) => {
+		lines.push(...generateModelBlock(entity));
+		lines.push("");
+	});
+	return lines.join("\n");
+}
+/**
+* Generate Prisma enum block.
+*/
+function generateEnumBlock(enumDef) {
+	const lines = [];
+	if (enumDef.description) lines.push(`/// ${enumDef.description}`);
+	lines.push(`enum ${enumDef.name} {`);
+	enumDef.values.forEach((value) => {
+		lines.push(`  ${value}`);
+	});
+	lines.push("");
+	if (enumDef.schema) lines.push(`  @@schema("${enumDef.schema}")`);
+	lines.push("}");
+	return lines;
+}
+/**
+* Generate Prisma model block from entity spec.
+*/
+function generateModelBlock(entity) {
+	const lines = [];
+	if (entity.description) lines.push(`/// ${entity.description}`);
+	lines.push(`model ${entity.name} {`);
+	Object.entries(entity.fields).forEach(([fieldName, field]) => {
+		const fieldLine = generateFieldLine(fieldName, field);
+		if (field.description) lines.push(`  /// ${field.description}`);
+		lines.push(`  ${fieldLine}`);
+	});
+	if (entity.indexes && entity.indexes.length > 0) {
+		lines.push("");
+		entity.indexes.forEach((idx) => {
+			lines.push(`  ${generateIndexLine(idx)}`);
+		});
+	}
+	if (entity.map) lines.push(`  @@map("${entity.map}")`);
+	if (entity.schema) lines.push(`  @@schema("${entity.schema}")`);
+	lines.push("}");
+	return lines;
+}
+/**
+* Generate a single field line.
+*/
+function generateFieldLine(fieldName, field) {
+	if (field.kind === "scalar") return generateScalarFieldLine(fieldName, field);
+	else if (field.kind === "enum") return generateEnumFieldLine(fieldName, field);
+	else if (field.kind === "relation") return generateRelationFieldLine(fieldName, field);
+	throw new Error(`Unknown field kind: ${field.kind}`);
+}
+/**
+* Generate scalar field line.
+*/
+function generateScalarFieldLine(fieldName, field) {
+	const parts = [fieldName];
+	let typeStr = field.type;
+	if (field.isArray) typeStr += "[]";
+	if (field.isOptional) typeStr += "?";
+	parts.push(typeStr);
+	const attrs = [];
+	if (field.isId) attrs.push("@id");
+	if (field.default !== void 0) if (typeof field.default === "string" && field.default.includes("(")) attrs.push(`@default(${field.default})`);
+	else if (typeof field.default === "boolean") attrs.push(`@default(${field.default})`);
+	else if (typeof field.default === "number") attrs.push(`@default(${field.default})`);
+	else attrs.push(`@default("${field.default}")`);
+	if (field.updatedAt) attrs.push("@updatedAt");
+	if (field.isUnique) attrs.push("@unique");
+	if (field.map) attrs.push(`@map("${field.map}")`);
+	if (field.dbType) attrs.push(`@db.${field.dbType}`);
+	if (attrs.length > 0) parts.push(attrs.join(" "));
+	return parts.join(" ");
+}
+/**
+* Generate enum field line.
+*/
+function generateEnumFieldLine(fieldName, field) {
+	const parts = [fieldName];
+	let typeStr = field.enumName;
+	if (field.isArray) typeStr += "[]";
+	if (field.isOptional) typeStr += "?";
+	parts.push(typeStr);
+	const attrs = [];
+	if (field.default !== void 0) attrs.push(`@default(${field.default})`);
+	if (field.isUnique) attrs.push("@unique");
+	if (field.map) attrs.push(`@map("${field.map}")`);
+	if (attrs.length > 0) parts.push(attrs.join(" "));
+	return parts.join(" ");
+}
+/**
+* Generate relation field line.
+*/
+function generateRelationFieldLine(fieldName, field) {
+	const parts = [fieldName];
+	let typeStr = field.target;
+	if (field.type === "hasMany") typeStr += "[]";
+	if (field.type === "hasOne") typeStr += "?";
+	parts.push(typeStr);
+	const relationParts = [];
+	if (field.name) relationParts.push(`name: "${field.name}"`);
+	if (field.fields && field.fields.length > 0) relationParts.push(`fields: [${field.fields.join(", ")}]`);
+	if (field.references && field.references.length > 0) relationParts.push(`references: [${field.references.join(", ")}]`);
+	if (field.onDelete) relationParts.push(`onDelete: ${field.onDelete}`);
+	if (field.onUpdate) relationParts.push(`onUpdate: ${field.onUpdate}`);
+	if (relationParts.length > 0) parts.push(`@relation(${relationParts.join(", ")})`);
+	return parts.join(" ");
+}
+/**
+* Generate index line.
+*/
+function generateIndexLine(idx) {
+	const fieldList = idx.fields.join(", ");
+	const parts = [];
+	if (idx.unique) parts.push(`@@unique([${fieldList}]`);
+	else parts.push(`@@index([${fieldList}]`);
+	const options = [];
+	if (idx.name) options.push(`name: "${idx.name}"`);
+	if (idx.type) options.push(`type: ${idx.type}`);
+	if (options.length > 0) parts[0] += `, ${options.join(", ")}`;
+	parts[0] += ")";
+	return parts.join("");
+}
+/**
+* Compose multiple module schema contributions into a single schema.
+*/
+function composeModuleSchemas(contributions, options = {}) {
+	const allEntities = [];
+	const allEnums = /* @__PURE__ */ new Map();
+	contributions.forEach((contrib) => {
+		contrib.entities.forEach((entity) => {
+			allEntities.push({
+				...entity,
+				module: contrib.moduleId
+			});
+		});
+		contrib.enums?.forEach((enumDef) => {
+			if (!allEnums.has(enumDef.name)) allEnums.set(enumDef.name, enumDef);
+		});
+	});
+	if (allEntities.length > 0 && allEnums.size > 0) allEntities[0] = {
+		...allEntities[0],
+		enums: [...allEntities[0].enums ?? [], ...allEnums.values()]
+	};
+	return generatePrismaSchema(allEntities, options);
+}
+/**
+* Generate a single entity's Prisma schema fragment (for modular output).
+*/
+function generateEntityFragment(entity) {
+	return generateModelBlock(entity).join("\n");
+}
+/**
+* Generate a single enum's Prisma schema fragment (for modular output).
+*/
+function generateEnumFragment(enumDef) {
+	return generateEnumBlock(enumDef).join("\n");
+}
+
+//#endregion
+export { composeModuleSchemas, generateEntityFragment, generateEnumFragment, generatePrismaSchema };

package/dist/entity/index.js

@@ -1 +1,5 @@
-import"./types.js";import{defineEntity as e,defineEntityEnum as t,field as n,index as r}from"./defineEntity.js";import{composeModuleSchemas as i,generateEntityFragment as a,generateEnumFragment as o,generatePrismaSchema as s}from"./generator.js";export{i as composeModuleSchemas,e as defineEntity,t as defineEntityEnum,n as field,a as generateEntityFragment,o as generateEnumFragment,s as generatePrismaSchema,r as index};
+import "./types.js";
+import { defineEntity, defineEntityEnum, field, index } from "./defineEntity.js";
+import { composeModuleSchemas, generateEntityFragment, generateEnumFragment, generatePrismaSchema } from "./generator.js";
+
+export { composeModuleSchemas, defineEntity, defineEntityEnum, field, generateEntityFragment, generateEnumFragment, generatePrismaSchema, index };

package/dist/entity/types.js

@@ -1 +1 @@
-import"zod";
+import "zod";

package/dist/index.js

@@ -1 +1,9 @@
-import{EnumType as e,defineEnum as t}from"./EnumType.js";import{FieldType as n}from"./FieldType.js";import{ScalarTypeEnum as r}from"./ScalarTypeEnum.js";import{SchemaModel as i,defineSchemaModel as a}from"./SchemaModel.js";import{defineEntity as o,defineEntityEnum as s,field as c,index as l}from"./entity/defineEntity.js";import{composeModuleSchemas as u,generateEntityFragment as d,generateEnumFragment as f,generatePrismaSchema as p}from"./entity/generator.js";import"./entity/index.js";export{e as EnumType,n as FieldType,r as ScalarTypeEnum,i as SchemaModel,u as composeModuleSchemas,o as defineEntity,s as defineEntityEnum,t as defineEnum,a as defineSchemaModel,c as field,d as generateEntityFragment,f as generateEnumFragment,p as generatePrismaSchema,l as index};
+import { EnumType, defineEnum } from "./EnumType.js";
+import { FieldType } from "./FieldType.js";
+import { ScalarTypeEnum } from "./ScalarTypeEnum.js";
+import { SchemaModel, defineSchemaModel } from "./SchemaModel.js";
+import { defineEntity, defineEntityEnum, field, index } from "./entity/defineEntity.js";
+import { composeModuleSchemas, generateEntityFragment, generateEnumFragment, generatePrismaSchema } from "./entity/generator.js";
+import "./entity/index.js";
+
+export { EnumType, FieldType, ScalarTypeEnum, SchemaModel, composeModuleSchemas, defineEntity, defineEntityEnum, defineEnum, defineSchemaModel, field, generateEntityFragment, generateEnumFragment, generatePrismaSchema, index };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.schema",
-  "version": "0.0.0-canary-20251217062943",
+  "version": "0.0.0-canary-20251217072406",
   "scripts": {
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
     "publish:pkg:canary": "bun publish:pkg --tag canary",
@@ -14,8 +14,8 @@
     "lint:check": "eslint src"
   },
   "devDependencies": {
-    "@lssm/tool.tsdown": "0.0.0-canary-20251217062943",
-    "@lssm/tool.typescript": "0.0.0-canary-20251217062943",
+    "@lssm/tool.tsdown": "0.0.0-canary-20251217072406",
+    "@lssm/tool.typescript": "0.0.0-canary-20251217072406",
     "tsdown": "^0.17.4",
     "typescript": "^5.9.3"
   },