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

package/dist/libs/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/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/schema/dist/SchemaModel.js

@@ -1,24 +1,39 @@
 import "./EnumType.js";
 import "./FieldType.js";
-import * as e$1 from "zod";
+import * as z$1 from "zod";
 
 //#region ../../libs/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$1, r]) => {
-			let i = r.type.getZod(), a = r.isArray ? e$1.array(i) : i;
-			return t$2[n$1] = 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;
 	}
 };
-const n = (e$2) => new t(e$2);
+/**
+* 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 { n, t };
+export { SchemaModel, defineSchemaModel };

package/dist/libs/schema/dist/index.js

@@ -1,6 +1,6 @@
-import { n, r } from "./EnumType.js";
-import { t as t$1 } from "./FieldType.js";
-import { l } from "./ScalarTypeEnum.js";
-import { n as n$1, t } from "./SchemaModel.js";
+import { EnumType, defineEnum } from "./EnumType.js";
+import { FieldType } from "./FieldType.js";
+import { ScalarTypeEnum } from "./ScalarTypeEnum.js";
+import { SchemaModel, defineSchemaModel } from "./SchemaModel.js";
 import "./entity/defineEntity.js";
 import "./entity/index.js";

package/dist/query/query.contracts.js

@@ -1,4 +1,4 @@
-import { n, t } from "../libs/contracts/dist/spec.js";
+import { defineCommand, defineQuery } from "../libs/contracts/dist/spec.js";
 import { CreateQueryInputModel, ExecuteQueryInputModel, QueryModel, QueryResultModel } from "./query.schema.js";
 
 //#region src/query/query.contracts.ts
@@ -6,7 +6,7 @@ const OWNERS = ["@example.analytics-dashboard"];
 /**
 * Create a data query.
 */
-const CreateQueryContract = t({
+const CreateQueryContract = defineCommand({
 	meta: {
 		name: "analytics.query.create",
 		version: 1,
@@ -39,7 +39,7 @@ const CreateQueryContract = t({
 /**
 * Execute a data query.
 */
-const ExecuteQueryContract = n({
+const ExecuteQueryContract = defineQuery({
 	meta: {
 		name: "analytics.query.execute",
 		version: 1,

package/dist/query/query.enum.d.ts

@@ -1,9 +1,9 @@
-import * as _lssm_lib_schema290 from "@lssm/lib.schema";
+import * as _lssm_lib_schema212 from "@lssm/lib.schema";
 
 //#region src/query/query.enum.d.ts
 /**
  * Query type enum.
  */
-declare const QueryTypeEnum: _lssm_lib_schema290.EnumType<[string, string, string, string]>;
+declare const QueryTypeEnum: _lssm_lib_schema212.EnumType<[string, string, string, string]>;
 //#endregion
 export { QueryTypeEnum };

package/dist/query/query.enum.js

@@ -1,11 +1,11 @@
-import { r } from "../libs/schema/dist/EnumType.js";
+import { defineEnum } from "../libs/schema/dist/EnumType.js";
 import "../libs/schema/dist/index.js";
 
 //#region src/query/query.enum.ts
 /**
 * Query type enum.
 */
-const QueryTypeEnum = r("QueryType", [
+const QueryTypeEnum = defineEnum("QueryType", [
 	"SQL",
 	"METRIC",
 	"AGGREGATION",