@lssm/example.analytics-dashboard 0.0.0-canary-20251217063201 → 0.0.0-canary-20251217072406

package/dist/libs/contracts/dist/schema/dist/ScalarTypeEnum.js

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

package/dist/libs/contracts/dist/schema/dist/SchemaModel.js

@@ -1,23 +1,34 @@
 import "./EnumType.js";
 import "./FieldType.js";
-import * as e$1 from "zod";
+import * as z$1 from "zod";
 
 //#region ../../libs/contracts/dist/schema/dist/SchemaModel.js
-var t = class {
-	constructor(e$2) {
-		this.config = e$2;
+/**
+* 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() {
-		let t$1 = Object.entries(this.config.fields).reduce((t$2, [n, r]) => {
-			let i = r.type.getZod(), a = r.isArray ? e$1.array(i) : i;
-			return t$2[n] = r.isOptional ? a.optional() : a, t$2;
+		const shape = Object.entries(this.config.fields).reduce((acc, [key, def]) => {
+			const base = def.type.getZod();
+			const withArray = def.isArray ? z$1.array(base) : base;
+			acc[key] = def.isOptional ? withArray.optional() : withArray;
+			return acc;
 		}, {});
-		return e$1.object(t$1);
+		return z$1.object(shape);
 	}
+	/** Input object name for GraphQL builder adapters. */
 	getPothosInput() {
 		return this.config.name;
 	}
 };
 
 //#endregion
-export { t };
+export { SchemaModel };

package/dist/libs/contracts/dist/server/mcp/registerPrompts.js

@@ -1 +1 @@
-import e from "zod";
+import z from "zod";

package/dist/libs/contracts/dist/spec.js

@@ -1,25 +1,34 @@
 //#region ../../libs/contracts/dist/spec.js
-const e = (e$1) => `ref` in e$1, t = (e$1) => ({
-	...e$1,
+/**
+* Helper to define a Command (write operation).
+* Sets `kind: 'command'` and defaults `idempotent: false`.
+*/
+const defineCommand = (spec) => ({
+	...spec,
 	meta: {
-		...e$1.meta,
-		kind: `command`
+		...spec.meta,
+		kind: "command"
 	},
 	policy: {
-		...e$1.policy,
-		idempotent: e$1.policy?.policy?.idempotent ?? !1
+		...spec.policy,
+		idempotent: spec.policy?.["policy"]?.idempotent ?? false
 	}
-}), n = (e$1) => ({
-	...e$1,
+});
+/**
+* Helper to define a Query (read-only operation).
+* Sets `kind: 'query'` and forces `idempotent: true`.
+*/
+const defineQuery = (spec) => ({
+	...spec,
 	meta: {
-		...e$1.meta,
-		kind: `query`
+		...spec.meta,
+		kind: "query"
 	},
 	policy: {
-		...e$1.policy,
-		idempotent: !0
+		...spec.policy,
+		idempotent: true
 	}
 });
 
 //#endregion
-export { n, t };
+export { defineCommand, defineQuery };

package/dist/libs/schema/dist/EnumType.js

@@ -1,40 +1,56 @@
-import * as e$1 from "zod";
+import * as z$1 from "zod";
 import { GraphQLEnumType } from "graphql";
 
 //#region ../../libs/schema/dist/EnumType.js
-var n = class {
+/**
+* Strongly-typed string enum wrapper with one source of truth for zod, GraphQL, and JSON Schema.
+*/
+var EnumType = class {
 	name;
 	values;
 	gqlEnum;
-	constructor(e$2, n$1) {
-		this.name = e$2, this.values = n$1, this.gqlEnum = new GraphQLEnumType({
+	constructor(name, values) {
+		this.name = name;
+		this.values = values;
+		this.gqlEnum = new GraphQLEnumType({
 			name: this.name,
-			values: Object.fromEntries(n$1.map((e$3) => [e$3, { value: e$3 }]))
+			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 e$1.enum(this.values);
+		return z$1.enum(this.values);
 	}
+	/** Minimal JSON representation (alias of getJsonSchema). */
 	getJson() {
 		return {
-			type: `string`,
+			type: "string",
 			enum: this.values
 		};
 	}
+	/** JSON Schema for this enum. */
 	getJsonSchema() {
 		return this.getJson();
 	}
 };
-const r = (e$2, t) => new n(e$2, t);
+/**
+* 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 { n, r };
+export { EnumType, defineEnum };

package/dist/libs/schema/dist/FieldType.js

@@ -2,38 +2,48 @@ import "zod";
 import { GraphQLScalarType } from "graphql";
 
 //#region ../../libs/schema/dist/FieldType.js
-var t = class extends GraphQLScalarType {
+/**
+* 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(e$1) {
-		super(e$1), this.zodSchema = e$1.zod, this.jsonSchemaDef = e$1.jsonSchema;
+	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;
+		return typeof this.jsonSchemaDef === "function" ? this.jsonSchemaDef() : this.jsonSchemaDef;
 	}
 	getJsonSchemaDef() {
 		return this.jsonSchemaDef;
 	}
 	getJsonSchema() {
-		let e$1 = (t$1) => {
-			let n = typeof t$1 == `function` ? t$1() : t$1;
-			if (Array.isArray(n)) return n.map((t$2) => e$1(t$2));
-			if (n && typeof n == `object`) {
-				let t$2 = {};
-				for (let [r, i] of Object.entries(n)) t$2[r] = e$1(i);
-				return t$2;
+		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 n;
+			return value;
 		};
-		return e$1(this.getJson());
+		return deepResolve(this.getJson());
 	}
 };
 
 //#endregion
-export { t };
+export { FieldType };