@ypanagidis/joqi 0.0.1

package/dist/src-DGGMT7nT.js

@@ -0,0 +1,1298 @@
+import { ZodError, z } from "zod";
+import { Effect, Schema } from "effect";
+
+//#region src/specs/query.ts
+const QueryVersionSchema = z.literal("v1");
+const QuerySortDirectionSchema = z.enum(["asc", "desc"]);
+const QueryFilterOperatorSchema = z.enum([
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"contains",
+	"startsWith",
+	"endsWith",
+	"isNull",
+	"isNotNull"
+]);
+const JsonScalarSchema = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+const QueryParamRefSchema = z.object({ $param: z.string().min(1) }).strict();
+const JsonValueSchema = z.lazy(() => z.union([
+	JsonScalarSchema,
+	z.array(JsonValueSchema),
+	z.record(z.string(), JsonValueSchema)
+]));
+const JsonLiteralValueSchema = JsonValueSchema.refine((value) => value === null || typeof value !== "object" || Array.isArray(value) || !Object.hasOwn(value, "$param"), { message: "Use {$param: string} without additional properties for parameter refs" });
+const QueryValueSchema = z.union([QueryParamRefSchema, JsonLiteralValueSchema]);
+const QueryLimitValueSchema = z.union([z.number().int().nonnegative(), QueryParamRefSchema]);
+const QueryParamsSchema = z.record(z.string(), JsonValueSchema);
+const QueryFilterSchema = z.lazy(() => z.union([
+	z.object({ and: z.array(QueryFilterSchema).min(1) }),
+	z.object({ or: z.array(QueryFilterSchema).min(1) }),
+	z.object({
+		field: z.string().min(1),
+		op: QueryFilterOperatorSchema,
+		value: QueryValueSchema.optional()
+	})
+]));
+const QueryOrderBySchema = z.object({
+	field: z.string().min(1),
+	direction: QuerySortDirectionSchema
+});
+const QuerySpecSchema = z.object({
+	version: QueryVersionSchema,
+	source: z.string().min(1),
+	select: z.array(z.string().min(1)).min(1),
+	where: QueryFilterSchema.optional(),
+	groupBy: z.array(z.string().min(1)).optional(),
+	orderBy: z.array(QueryOrderBySchema).optional(),
+	limit: QueryLimitValueSchema.optional(),
+	offset: QueryLimitValueSchema.optional()
+});
+const parseQuerySpec = (input) => QuerySpecSchema.parse(input);
+const safeParseQuerySpec = (input) => QuerySpecSchema.safeParse(input);
+
+//#endregion
+//#region src/specs/registries.ts
+const RegistryVersionSchema = z.literal("v1");
+const FieldTypeSchema = z.enum([
+	"string",
+	"number",
+	"boolean",
+	"date",
+	"datetime",
+	"json",
+	"enum",
+	"unknown"
+]);
+const PhysicalSourceKindSchema = z.enum([
+	"table",
+	"view",
+	"model"
+]);
+const RelationKindSchema = z.enum(["one", "many"]);
+const AggregationSchema = z.enum([
+	"count",
+	"sum",
+	"avg",
+	"min",
+	"max"
+]);
+const ExposureModeSchema = z.enum(["deny-by-default", "allow-by-default"]);
+const nonEmptyRecord = (valueSchema) => z.record(z.string().min(1), valueSchema).refine((value) => Object.keys(value).length > 0, { message: "Expected at least one entry" });
+const AdapterMetaSchema = z.record(z.string().min(1), z.unknown());
+const PhysicalFieldSchema = z.object({
+	type: FieldTypeSchema,
+	nullable: z.boolean(),
+	enumValues: z.array(z.string()).optional(),
+	adapterMeta: AdapterMetaSchema.optional()
+});
+const PhysicalRelationSchema = z.object({
+	kind: RelationKindSchema,
+	target: z.string().min(1),
+	localFields: z.array(z.string().min(1)).min(1),
+	foreignFields: z.array(z.string().min(1)).min(1),
+	nullable: z.boolean().optional(),
+	adapterMeta: AdapterMetaSchema.optional()
+});
+const PhysicalSourceSchema = z.object({
+	kind: PhysicalSourceKindSchema,
+	name: z.string().min(1),
+	schema: z.string().min(1).optional(),
+	primaryKey: z.array(z.string().min(1)).optional(),
+	fields: nonEmptyRecord(PhysicalFieldSchema),
+	relations: z.record(z.string().min(1), PhysicalRelationSchema).optional(),
+	adapterMeta: AdapterMetaSchema.optional()
+});
+const PhysicalRegistrySchema = z.object({
+	version: RegistryVersionSchema,
+	sources: nonEmptyRecord(PhysicalSourceSchema)
+});
+const FieldPolicySchema = z.object({
+	expose: z.boolean().optional(),
+	exposeAs: z.string().min(1).optional(),
+	label: z.string().min(1).optional(),
+	description: z.string().min(1).optional(),
+	type: FieldTypeSchema.exclude(["unknown"]).optional(),
+	selectable: z.boolean().optional(),
+	filterable: z.boolean().optional(),
+	sortable: z.boolean().optional(),
+	groupable: z.boolean().optional(),
+	operators: z.array(QueryFilterOperatorSchema).optional(),
+	aggregations: z.array(AggregationSchema).optional()
+});
+const RelationPolicySchema = z.object({
+	expose: z.boolean().optional(),
+	exposeAs: z.string().min(1).optional(),
+	target: z.string().min(1).optional(),
+	selectable: z.boolean().optional(),
+	filterable: z.boolean().optional(),
+	maxDepth: z.number().int().nonnegative().optional()
+});
+const SourcePolicySchema = z.object({
+	expose: z.boolean().optional(),
+	exposeAs: z.string().min(1).optional(),
+	label: z.string().min(1).optional(),
+	description: z.string().min(1).optional(),
+	selectable: z.boolean().optional(),
+	filterable: z.boolean().optional(),
+	sortable: z.boolean().optional(),
+	maxLimit: z.number().int().nonnegative().optional(),
+	defaultLimit: z.number().int().nonnegative().optional(),
+	fields: z.record(z.string().min(1), FieldPolicySchema).optional(),
+	relations: z.record(z.string().min(1), RelationPolicySchema).optional()
+});
+const RegistryPolicySchema = z.object({
+	version: RegistryVersionSchema,
+	sources: z.record(z.string().min(1), SourcePolicySchema).optional()
+});
+const SourceDefaultsSchema = z.object({
+	selectable: z.boolean().optional(),
+	filterable: z.boolean().optional(),
+	sortable: z.boolean().optional(),
+	maxLimit: z.number().int().nonnegative().optional()
+});
+const FieldDefaultsSchema = z.object({
+	selectable: z.boolean().optional(),
+	filterable: z.boolean().optional(),
+	sortable: z.boolean().optional(),
+	groupable: z.boolean().optional(),
+	operators: z.union([z.literal("byType"), z.array(QueryFilterOperatorSchema)]).optional()
+});
+const RelationDefaultsSchema = z.object({
+	selectable: z.boolean().optional(),
+	filterable: z.boolean().optional(),
+	maxDepth: z.number().int().nonnegative().optional()
+});
+const RegistryDefaultsSchema = z.object({
+	exposure: ExposureModeSchema.default("deny-by-default"),
+	source: SourceDefaultsSchema.optional(),
+	field: FieldDefaultsSchema.optional(),
+	relation: RelationDefaultsSchema.optional()
+});
+const ResolvedFieldSchema = z.object({
+	physicalSource: z.string().min(1),
+	physicalField: z.string().min(1),
+	publicName: z.string().min(1),
+	type: FieldTypeSchema,
+	nullable: z.boolean(),
+	label: z.string().min(1).optional(),
+	description: z.string().min(1).optional(),
+	selectable: z.boolean(),
+	filterable: z.boolean(),
+	sortable: z.boolean(),
+	groupable: z.boolean(),
+	operators: z.array(QueryFilterOperatorSchema),
+	aggregations: z.array(AggregationSchema)
+});
+const ResolvedRelationSchema = z.object({
+	physicalSource: z.string().min(1),
+	physicalRelation: z.string().min(1),
+	publicName: z.string().min(1),
+	target: z.string().min(1),
+	kind: RelationKindSchema,
+	localFields: z.array(z.string().min(1)).min(1),
+	foreignFields: z.array(z.string().min(1)).min(1),
+	selectable: z.boolean(),
+	filterable: z.boolean(),
+	maxDepth: z.number().int().nonnegative()
+});
+const ResolvedSourceSchema = z.object({
+	physicalSource: z.string().min(1),
+	publicName: z.string().min(1),
+	label: z.string().min(1).optional(),
+	description: z.string().min(1).optional(),
+	maxLimit: z.number().int().nonnegative().optional(),
+	defaultLimit: z.number().int().nonnegative().optional(),
+	fields: nonEmptyRecord(ResolvedFieldSchema),
+	relations: z.record(z.string().min(1), ResolvedRelationSchema)
+});
+const ResolvedRegistrySchema = z.object({
+	version: RegistryVersionSchema,
+	sources: z.record(z.string().min(1), ResolvedSourceSchema)
+});
+const parsePhysicalRegistry = (input) => PhysicalRegistrySchema.parse(input);
+const parseRegistryPolicy = (input) => RegistryPolicySchema.parse(input);
+const parseRegistryDefaults = (input) => RegistryDefaultsSchema.parse(input);
+const parseResolvedRegistry = (input) => ResolvedRegistrySchema.parse(input);
+const safeParsePhysicalRegistry = (input) => PhysicalRegistrySchema.safeParse(input);
+const safeParseRegistryPolicy = (input) => RegistryPolicySchema.safeParse(input);
+const safeParseRegistryDefaults = (input) => RegistryDefaultsSchema.safeParse(input);
+const safeParseResolvedRegistry = (input) => ResolvedRegistrySchema.safeParse(input);
+
+//#endregion
+//#region src/registry/resolve.ts
+const FieldTypeErrorSchema = Schema.Literal("string", "number", "boolean", "date", "datetime", "json", "enum", "unknown");
+const QueryFilterOperatorErrorSchema$1 = Schema.Literal("eq", "neq", "gt", "gte", "lt", "lte", "in", "contains", "startsWith", "endsWith", "isNull", "isNotNull");
+const RegistryResolutionIssueSchema = Schema.Union(Schema.Struct({
+	code: Schema.Literal("unknown_source"),
+	source: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("unknown_field"),
+	source: Schema.String,
+	field: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("unknown_relation"),
+	source: Schema.String,
+	relation: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("duplicate_public_source"),
+	publicName: Schema.String,
+	sources: Schema.Array(Schema.String)
+}), Schema.Struct({
+	code: Schema.Literal("duplicate_public_field"),
+	source: Schema.String,
+	publicName: Schema.String,
+	fields: Schema.Array(Schema.String)
+}), Schema.Struct({
+	code: Schema.Literal("duplicate_public_relation"),
+	source: Schema.String,
+	publicName: Schema.String,
+	relations: Schema.Array(Schema.String)
+}), Schema.Struct({
+	code: Schema.Literal("source_has_no_fields"),
+	source: Schema.String,
+	publicName: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("invalid_default_limit"),
+	source: Schema.String,
+	defaultLimit: Schema.Number,
+	maxLimit: Schema.Number
+}), Schema.Struct({
+	code: Schema.Literal("unknown_relation_target"),
+	source: Schema.String,
+	relation: Schema.String,
+	target: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("invalid_operator_for_field_type"),
+	source: Schema.String,
+	field: Schema.String,
+	type: FieldTypeErrorSchema,
+	operator: QueryFilterOperatorErrorSchema$1
+}));
+var RegistryResolutionError = class extends Schema.TaggedError()("RegistryResolutionError", { issues: Schema.Array(RegistryResolutionIssueSchema) }) {};
+var RegistryParseError = class extends Schema.TaggedError()("RegistryParseError", { error: Schema.Defect }) {};
+const resolveRegistryEffect = Effect.fn("resolveRegistry")(function* (input) {
+	const physical = yield* parseRegistryInput(() => PhysicalRegistrySchema.parse(input.physical));
+	const defaults = yield* parseRegistryInput(() => RegistryDefaultsSchema.parse(input.defaults ?? {}));
+	const policy = mergePolicies(yield* parsePolicies(input));
+	const issues = [];
+	collectStalePolicyReferenceIssues(physical, policy, issues);
+	if (issues.length > 0) return yield* new RegistryResolutionError({ issues });
+	const publicSourcesByPhysical = /* @__PURE__ */ new Map();
+	const physicalSourcesByPublic = /* @__PURE__ */ new Map();
+	const duplicateSourceIssues = [];
+	for (const sourceName of Object.keys(physical.sources)) {
+		const sourcePolicy = policy[sourceName];
+		if (!isExposed(defaults, sourcePolicy?.expose)) continue;
+		const publicName = sourcePolicy?.exposeAs ?? sourceName;
+		const existingSource = physicalSourcesByPublic.get(publicName);
+		if (existingSource !== void 0) {
+			duplicateSourceIssues.push({
+				code: "duplicate_public_source",
+				publicName,
+				sources: [existingSource, sourceName]
+			});
+			continue;
+		}
+		physicalSourcesByPublic.set(publicName, sourceName);
+		publicSourcesByPhysical.set(sourceName, publicName);
+	}
+	const sources = {};
+	for (const [sourceName, physicalSource] of Object.entries(physical.sources)) {
+		const publicName = publicSourcesByPhysical.get(sourceName);
+		if (publicName === void 0) continue;
+		const sourcePolicy = policy[sourceName];
+		const sourceCapabilities = resolveSourceCapabilities(defaults, sourcePolicy);
+		const fields = resolveFields({
+			sourceName,
+			physicalFields: physicalSource.fields,
+			defaults,
+			sourcePolicy,
+			sourceCapabilities,
+			issues
+		});
+		const relations = resolveRelations({
+			sourceName,
+			physicalRelations: physicalSource.relations ?? {},
+			defaults,
+			sourcePolicy,
+			sourceCapabilities,
+			publicSourcesByPhysical,
+			physicalSourcesByPublic,
+			issues
+		});
+		if (Object.keys(fields).length === 0) {
+			issues.push({
+				code: "source_has_no_fields",
+				source: sourceName,
+				publicName
+			});
+			continue;
+		}
+		const maxLimit = sourcePolicy?.maxLimit ?? defaults.source?.maxLimit;
+		const defaultLimit = sourcePolicy?.defaultLimit;
+		if (defaultLimit !== void 0 && maxLimit !== void 0 && defaultLimit > maxLimit) {
+			issues.push({
+				code: "invalid_default_limit",
+				source: sourceName,
+				defaultLimit,
+				maxLimit
+			});
+			continue;
+		}
+		sources[publicName] = {
+			physicalSource: sourceName,
+			publicName,
+			...sourcePolicy?.label === void 0 ? {} : { label: sourcePolicy.label },
+			...sourcePolicy?.description === void 0 ? {} : { description: sourcePolicy.description },
+			...maxLimit === void 0 ? {} : { maxLimit },
+			...defaultLimit === void 0 ? {} : { defaultLimit },
+			fields,
+			relations
+		};
+	}
+	issues.push(...duplicateSourceIssues);
+	if (issues.length > 0) return yield* new RegistryResolutionError({ issues });
+	return yield* parseRegistryInput(() => ResolvedRegistrySchema.parse({
+		version: "v1",
+		sources
+	}));
+});
+const resolveRegistry = (input) => unwrapResolveRegistryResult(Effect.runSync(Effect.either(resolveRegistryEffect(input))));
+const resolveRegistryPromise = async (input) => unwrapResolveRegistryResult(await Effect.runPromise(Effect.either(resolveRegistryEffect(input))));
+const parseRegistryInput = (parse) => Effect.try({
+	try: parse,
+	catch: (error) => {
+		if (error instanceof ZodError) return new RegistryParseError({ error });
+		throw error;
+	}
+});
+const unwrapResolveRegistryResult = (result) => {
+	if (result._tag === "Left") throw result.left;
+	return result.right;
+};
+const parsePolicies = Effect.fn("parseRegistryPolicies")(function* (input) {
+	const policies = [];
+	if (input.policy !== void 0) policies.push(yield* parseRegistryInput(() => RegistryPolicySchema.parse(input.policy)));
+	for (const policy of input.policies ?? []) policies.push(yield* parseRegistryInput(() => RegistryPolicySchema.parse(policy)));
+	return policies;
+});
+const mergePolicies = (policies) => {
+	const merged = {};
+	for (const policy of policies) for (const [sourceName, sourcePolicy] of Object.entries(policy.sources ?? {})) {
+		const currentSourcePolicy = merged[sourceName] ?? {};
+		const fields = mergeNestedPolicy(currentSourcePolicy.fields, sourcePolicy.fields);
+		const relations = mergeNestedPolicy(currentSourcePolicy.relations, sourcePolicy.relations);
+		merged[sourceName] = {
+			...currentSourcePolicy,
+			...sourcePolicy,
+			...fields === void 0 ? {} : { fields },
+			...relations === void 0 ? {} : { relations }
+		};
+	}
+	return merged;
+};
+const mergeNestedPolicy = (current, next) => {
+	if (current === void 0 && next === void 0) return;
+	const merged = { ...current };
+	for (const [name, policy] of Object.entries(next ?? {})) merged[name] = {
+		...merged[name],
+		...policy
+	};
+	return merged;
+};
+const collectStalePolicyReferenceIssues = (physical, policy, issues) => {
+	for (const [sourceName, sourcePolicy] of Object.entries(policy)) {
+		const physicalSource = physical.sources[sourceName];
+		if (physicalSource === void 0) {
+			issues.push({
+				code: "unknown_source",
+				source: sourceName
+			});
+			continue;
+		}
+		for (const fieldName of Object.keys(sourcePolicy.fields ?? {})) if (physicalSource.fields[fieldName] === void 0) issues.push({
+			code: "unknown_field",
+			source: sourceName,
+			field: fieldName
+		});
+		for (const relationName of Object.keys(sourcePolicy.relations ?? {})) if (physicalSource.relations?.[relationName] === void 0) issues.push({
+			code: "unknown_relation",
+			source: sourceName,
+			relation: relationName
+		});
+	}
+};
+const isExposed = (defaults, expose) => {
+	if (expose !== void 0) return expose;
+	return defaults.exposure === "allow-by-default";
+};
+const resolveSourceCapabilities = (defaults, sourcePolicy) => ({
+	selectable: sourcePolicy?.selectable ?? defaults.source?.selectable ?? true,
+	filterable: sourcePolicy?.filterable ?? defaults.source?.filterable ?? true,
+	sortable: sourcePolicy?.sortable ?? defaults.source?.sortable ?? true
+});
+const resolveFields = (input) => {
+	const fields = {};
+	const physicalFieldsByPublic = /* @__PURE__ */ new Map();
+	for (const [fieldName, physicalField] of Object.entries(input.physicalFields)) {
+		const fieldPolicy = input.sourcePolicy?.fields?.[fieldName];
+		if (!isExposed(input.defaults, fieldPolicy?.expose)) continue;
+		const publicName = fieldPolicy?.exposeAs ?? fieldName;
+		const existingField = physicalFieldsByPublic.get(publicName);
+		if (existingField !== void 0) {
+			input.issues.push({
+				code: "duplicate_public_field",
+				source: input.sourceName,
+				publicName,
+				fields: [existingField, fieldName]
+			});
+			continue;
+		}
+		physicalFieldsByPublic.set(publicName, fieldName);
+		const type = fieldPolicy?.type ?? physicalField.type;
+		const selectable = input.sourceCapabilities.selectable && (fieldPolicy?.selectable ?? input.defaults.field?.selectable ?? true);
+		const filterable = input.sourceCapabilities.filterable && (fieldPolicy?.filterable ?? input.defaults.field?.filterable ?? false);
+		const sortable = input.sourceCapabilities.sortable && (fieldPolicy?.sortable ?? input.defaults.field?.sortable ?? false);
+		const operators = filterable ? resolveOperators({
+			sourceName: input.sourceName,
+			fieldName,
+			type,
+			fieldPolicy,
+			defaults: input.defaults,
+			issues: input.issues
+		}) : [];
+		fields[publicName] = {
+			physicalSource: input.sourceName,
+			physicalField: fieldName,
+			publicName,
+			type,
+			nullable: physicalField.nullable,
+			...fieldPolicy?.label === void 0 ? {} : { label: fieldPolicy.label },
+			...fieldPolicy?.description === void 0 ? {} : { description: fieldPolicy.description },
+			selectable,
+			filterable,
+			sortable,
+			groupable: fieldPolicy?.groupable ?? input.defaults.field?.groupable ?? false,
+			operators,
+			aggregations: fieldPolicy?.aggregations ?? []
+		};
+	}
+	return fields;
+};
+const resolveRelations = (input) => {
+	const relations = {};
+	const physicalRelationsByPublic = /* @__PURE__ */ new Map();
+	for (const [relationName, physicalRelation] of Object.entries(input.physicalRelations)) {
+		const relationPolicy = input.sourcePolicy?.relations?.[relationName];
+		if (!isExposed(input.defaults, relationPolicy?.expose)) continue;
+		const publicName = relationPolicy?.exposeAs ?? relationName;
+		const existingRelation = physicalRelationsByPublic.get(publicName);
+		if (existingRelation !== void 0) {
+			input.issues.push({
+				code: "duplicate_public_relation",
+				source: input.sourceName,
+				publicName,
+				relations: [existingRelation, relationName]
+			});
+			continue;
+		}
+		const target = relationPolicy?.target ?? input.publicSourcesByPhysical.get(physicalRelation.target);
+		if (target === void 0 || !input.physicalSourcesByPublic.has(target)) {
+			if (relationPolicy?.expose === true) input.issues.push({
+				code: "unknown_relation_target",
+				source: input.sourceName,
+				relation: relationName,
+				target: relationPolicy?.target ?? physicalRelation.target
+			});
+			continue;
+		}
+		physicalRelationsByPublic.set(publicName, relationName);
+		relations[publicName] = {
+			physicalSource: input.sourceName,
+			physicalRelation: relationName,
+			publicName,
+			target,
+			kind: physicalRelation.kind,
+			localFields: physicalRelation.localFields,
+			foreignFields: physicalRelation.foreignFields,
+			selectable: input.sourceCapabilities.selectable && (relationPolicy?.selectable ?? input.defaults.relation?.selectable ?? false),
+			filterable: input.sourceCapabilities.filterable && (relationPolicy?.filterable ?? input.defaults.relation?.filterable ?? false),
+			maxDepth: relationPolicy?.maxDepth ?? input.defaults.relation?.maxDepth ?? 1
+		};
+	}
+	return relations;
+};
+const resolveOperators = (input) => {
+	const requestedOperators = input.fieldPolicy?.operators ?? input.defaults.field?.operators ?? "byType";
+	const operators = requestedOperators === "byType" ? defaultOperatorsByType[input.type] : requestedOperators;
+	const validOperators = new Set(defaultOperatorsByType[input.type]);
+	for (const operator of operators) if (!validOperators.has(operator)) input.issues.push({
+		code: "invalid_operator_for_field_type",
+		source: input.sourceName,
+		field: input.fieldName,
+		type: input.type,
+		operator
+	});
+	return [...operators];
+};
+const nullableOperators = ["isNull", "isNotNull"];
+const equalityOperators = [
+	"eq",
+	"neq",
+	"in",
+	...nullableOperators
+];
+const comparableOperators = [
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	...nullableOperators
+];
+const defaultOperatorsByType = {
+	string: [
+		"eq",
+		"neq",
+		"in",
+		"contains",
+		"startsWith",
+		"endsWith",
+		...nullableOperators
+	],
+	number: comparableOperators,
+	boolean: [
+		"eq",
+		"neq",
+		...nullableOperators
+	],
+	date: comparableOperators,
+	datetime: comparableOperators,
+	json: [
+		"eq",
+		"neq",
+		...nullableOperators
+	],
+	enum: equalityOperators,
+	unknown: []
+};
+
+//#endregion
+//#region src/query/validate.ts
+const QueryFilterOperatorErrorSchema = Schema.Literal("eq", "neq", "gt", "gte", "lt", "lte", "in", "contains", "startsWith", "endsWith", "isNull", "isNotNull");
+const QueryValidationIssueSchema = Schema.Union(Schema.Struct({
+	code: Schema.Literal("unknown_source"),
+	source: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("unknown_field"),
+	source: Schema.String,
+	path: Schema.String,
+	field: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("unknown_relation"),
+	source: Schema.String,
+	path: Schema.String,
+	relation: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("field_not_selectable", "field_not_filterable", "field_not_sortable", "field_not_groupable"),
+	source: Schema.String,
+	path: Schema.String,
+	field: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("relation_not_selectable", "relation_not_filterable"),
+	source: Schema.String,
+	path: Schema.String,
+	relation: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("relation_depth_exceeded"),
+	source: Schema.String,
+	path: Schema.String,
+	relation: Schema.String,
+	requestedDepth: Schema.Number,
+	maxDepth: Schema.Number
+}), Schema.Struct({
+	code: Schema.Literal("operator_not_allowed"),
+	source: Schema.String,
+	path: Schema.String,
+	field: Schema.String,
+	operator: QueryFilterOperatorErrorSchema,
+	allowedOperators: Schema.Array(QueryFilterOperatorErrorSchema)
+}), Schema.Struct({
+	code: Schema.Literal("limit_exceeds_max"),
+	source: Schema.String,
+	limit: Schema.Number,
+	maxLimit: Schema.Number
+}), Schema.Struct({
+	code: Schema.Literal("missing_param"),
+	param: Schema.String,
+	path: Schema.String
+}), Schema.Struct({
+	code: Schema.Literal("invalid_param_value"),
+	param: Schema.String,
+	path: Schema.String,
+	expected: Schema.String
+}));
+var QueryParseError = class extends Schema.TaggedError()("QueryParseError", {
+	input: Schema.Literal("query", "registry", "params"),
+	error: Schema.Defect
+}) {};
+var QueryValidationError = class extends Schema.TaggedError()("QueryValidationError", { issues: Schema.Array(QueryValidationIssueSchema) }) {};
+const validateQuerySpecEffect = Effect.fn("validateQuerySpec")(function* (input) {
+	const parsedQuery = yield* parseValidationInput("query", () => QuerySpecSchema.parse(input.query));
+	const params = yield* parseValidationInput("params", () => QueryParamsSchema.parse(input.params ?? {}));
+	const registry = yield* parseValidationInput("registry", () => ResolvedRegistrySchema.parse(input.registry));
+	const issues = [];
+	const query = bindQueryParams({
+		query: parsedQuery,
+		params,
+		issues
+	});
+	const source = registry.sources[query.source];
+	if (source === void 0) return yield* new QueryValidationError({ issues: [{
+		code: "unknown_source",
+		source: query.source
+	}] });
+	validateLimit(query, source, issues);
+	for (const fieldPath of query.select) validateFieldPath({
+		registry,
+		source,
+		fieldPath,
+		fieldCapability: "selectable",
+		relationCapability: "selectable",
+		issues
+	});
+	if (query.where !== void 0) validateFilter({
+		registry,
+		source,
+		filter: query.where,
+		issues
+	});
+	for (const fieldPath of query.groupBy ?? []) validateFieldPath({
+		registry,
+		source,
+		fieldPath,
+		fieldCapability: "groupable",
+		relationCapability: "selectable",
+		issues
+	});
+	for (const orderBy of query.orderBy ?? []) validateFieldPath({
+		registry,
+		source,
+		fieldPath: orderBy.field,
+		fieldCapability: "sortable",
+		relationCapability: "selectable",
+		issues
+	});
+	if (issues.length > 0) return yield* new QueryValidationError({ issues });
+	return stripQueryParamSources(query);
+});
+const validateQuerySpec = (input) => unwrapValidateQuerySpecResult(Effect.runSync(Effect.either(validateQuerySpecEffect(input))));
+const validateQuerySpecPromise = async (input) => unwrapValidateQuerySpecResult(await Effect.runPromise(Effect.either(validateQuerySpecEffect(input))));
+const parseValidationInput = (input, parse) => Effect.try({
+	try: parse,
+	catch: (error) => {
+		if (error instanceof ZodError) return new QueryParseError({
+			input,
+			error
+		});
+		throw error;
+	}
+});
+const unwrapValidateQuerySpecResult = (result) => {
+	if (result._tag === "Left") throw result.left;
+	return result.right;
+};
+const stripQueryParamSources = (query) => ({
+	version: query.version,
+	source: query.source,
+	select: query.select,
+	...query.groupBy === void 0 ? {} : { groupBy: query.groupBy },
+	...query.orderBy === void 0 ? {} : { orderBy: query.orderBy },
+	...query.where === void 0 ? {} : { where: stripFilterParamSources(query.where) },
+	...query.limit === void 0 ? {} : { limit: query.limit },
+	...query.offset === void 0 ? {} : { offset: query.offset }
+});
+const stripFilterParamSources = (filter) => {
+	if ("and" in filter) return { and: filter.and.map(stripFilterParamSources) };
+	if ("or" in filter) return { or: filter.or.map(stripFilterParamSources) };
+	return {
+		field: filter.field,
+		op: filter.op,
+		...filter.value === void 0 ? {} : { value: filter.value }
+	};
+};
+const bindQueryParams = (input) => ({
+	version: input.query.version,
+	source: input.query.source,
+	select: input.query.select,
+	...input.query.groupBy === void 0 ? {} : { groupBy: input.query.groupBy },
+	...input.query.orderBy === void 0 ? {} : { orderBy: input.query.orderBy },
+	...input.query.where === void 0 ? {} : { where: bindFilterParams({
+		...input,
+		filter: input.query.where,
+		path: "where"
+	}) },
+	...input.query.limit === void 0 ? {} : { limit: bindLimitParam({
+		...input,
+		value: input.query.limit,
+		path: "limit"
+	}) },
+	...input.query.offset === void 0 ? {} : { offset: bindLimitParam({
+		...input,
+		value: input.query.offset,
+		path: "offset"
+	}) }
+});
+const bindFilterParams = (input) => {
+	if ("and" in input.filter) return { and: input.filter.and.map((filter, index) => bindFilterParams({
+		...input,
+		filter,
+		path: `${input.path}.and[${index}]`
+	})) };
+	if ("or" in input.filter) return { or: input.filter.or.map((filter, index) => bindFilterParams({
+		...input,
+		filter,
+		path: `${input.path}.or[${index}]`
+	})) };
+	if (input.filter.value === void 0) return {
+		field: input.filter.field,
+		op: input.filter.op
+	};
+	const value = bindJsonParam({
+		params: input.params,
+		issues: input.issues,
+		value: input.filter.value,
+		path: `${input.path}.value`
+	});
+	if (input.filter.op === "in" && isQueryParamRef(input.filter.value) && Object.hasOwn(input.params, input.filter.value.$param) && (!Array.isArray(value) || value.length === 0)) input.issues.push({
+		code: "invalid_param_value",
+		param: input.filter.value.$param,
+		path: `${input.path}.value`,
+		expected: "non-empty array"
+	});
+	return {
+		field: input.filter.field,
+		op: input.filter.op,
+		value,
+		...isQueryParamRef(input.filter.value) ? { valueParam: input.filter.value.$param } : {}
+	};
+};
+const bindLimitParam = (input) => {
+	if (typeof input.value === "number") return input.value;
+	if (isQueryParamRef(input.value) && !Object.hasOwn(input.params, input.value.$param)) {
+		input.issues.push({
+			code: "missing_param",
+			param: input.value.$param,
+			path: input.path
+		});
+		return;
+	}
+	const value = bindJsonParam({
+		params: input.params,
+		issues: input.issues,
+		value: input.value,
+		path: input.path
+	});
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
+	if (isQueryParamRef(input.value)) input.issues.push({
+		code: "invalid_param_value",
+		param: input.value.$param,
+		path: input.path,
+		expected: "non-negative integer"
+	});
+};
+const bindJsonParam = (input) => {
+	if (!isQueryParamRef(input.value)) return input.value;
+	if (!Object.hasOwn(input.params, input.value.$param)) {
+		input.issues.push({
+			code: "missing_param",
+			param: input.value.$param,
+			path: input.path
+		});
+		return;
+	}
+	return input.params[input.value.$param];
+};
+const isQueryParamRef = (value) => value !== null && typeof value === "object" && Object.keys(value).length === 1 && typeof value.$param === "string";
+const validateLimit = (query, source, issues) => {
+	if (query.limit !== void 0 && source.maxLimit !== void 0 && query.limit > source.maxLimit) issues.push({
+		code: "limit_exceeds_max",
+		source: source.publicName,
+		limit: query.limit,
+		maxLimit: source.maxLimit
+	});
+};
+const validateFilter = (input) => {
+	if ("and" in input.filter) {
+		for (const filter of input.filter.and) validateFilter({
+			...input,
+			filter
+		});
+		return;
+	}
+	if ("or" in input.filter) {
+		for (const filter of input.filter.or) validateFilter({
+			...input,
+			filter
+		});
+		return;
+	}
+	const result = validateFieldPath({
+		registry: input.registry,
+		source: input.source,
+		fieldPath: input.filter.field,
+		fieldCapability: "filterable",
+		relationCapability: "filterable",
+		issues: input.issues
+	});
+	if (result === void 0 || !result.field.filterable) return;
+	if (!result.field.operators.includes(input.filter.op)) input.issues.push({
+		code: "operator_not_allowed",
+		source: result.source.publicName,
+		path: input.filter.field,
+		field: result.field.publicName,
+		operator: input.filter.op,
+		allowedOperators: result.field.operators
+	});
+	validateFilterParamValue({
+		filter: input.filter,
+		field: result.field,
+		issues: input.issues
+	});
+};
+const validateFilterParamValue = (input) => {
+	if (input.filter.valueParam === void 0 || input.filter.value === void 0) return;
+	if (input.filter.op === "isNull" || input.filter.op === "isNotNull") return;
+	if (input.filter.op === "in") {
+		if (!Array.isArray(input.filter.value) || input.filter.value.length === 0) return;
+		if (input.filter.value.some((value) => !isValueForFieldType(value, input.field.type))) input.issues.push({
+			code: "invalid_param_value",
+			param: input.filter.valueParam,
+			path: `${input.filter.field}.value`,
+			expected: `array of ${fieldTypeExpectation(input.field.type)}`
+		});
+		return;
+	}
+	if (!isValueForFieldType(input.filter.value, input.field.type)) input.issues.push({
+		code: "invalid_param_value",
+		param: input.filter.valueParam,
+		path: `${input.filter.field}.value`,
+		expected: fieldTypeExpectation(input.field.type)
+	});
+};
+const isValueForFieldType = (value, type) => {
+	if (value === null) return true;
+	switch (type) {
+		case "number": return typeof value === "number";
+		case "boolean": return typeof value === "boolean";
+		case "string":
+		case "enum":
+		case "date":
+		case "datetime": return typeof value === "string";
+		case "json":
+		case "unknown": return true;
+	}
+};
+const fieldTypeExpectation = (type) => {
+	switch (type) {
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "string":
+		case "enum":
+		case "date":
+		case "datetime": return "string";
+		case "json":
+		case "unknown": return "JSON value";
+	}
+};
+const validateFieldPath = (input) => {
+	const parts = input.fieldPath.split(".");
+	const fieldName = parts.at(-1);
+	if (fieldName === void 0 || fieldName.length === 0) return;
+	let source = input.source;
+	const relationNames = parts.slice(0, -1);
+	for (const [index, relationName] of relationNames.entries()) {
+		const relation = source.relations[relationName];
+		if (relation === void 0) {
+			input.issues.push({
+				code: "unknown_relation",
+				source: source.publicName,
+				path: input.fieldPath,
+				relation: relationName
+			});
+			return;
+		}
+		validateRelationPath({
+			relation,
+			source,
+			relationName,
+			requestedDepth: relationNames.length - index,
+			fieldPath: input.fieldPath,
+			relationCapability: input.relationCapability,
+			issues: input.issues
+		});
+		const targetSource = input.registry.sources[relation.target];
+		if (targetSource === void 0) {
+			input.issues.push({
+				code: "unknown_source",
+				source: relation.target
+			});
+			return;
+		}
+		source = targetSource;
+	}
+	const field = source.fields[fieldName];
+	if (field === void 0) {
+		input.issues.push({
+			code: "unknown_field",
+			source: source.publicName,
+			path: input.fieldPath,
+			field: fieldName
+		});
+		return;
+	}
+	validateFieldCapability({
+		source,
+		field,
+		fieldPath: input.fieldPath,
+		fieldCapability: input.fieldCapability,
+		issues: input.issues
+	});
+	return {
+		source,
+		field
+	};
+};
+const validateRelationPath = (input) => {
+	if (!input.relation[input.relationCapability]) input.issues.push({
+		code: input.relationCapability === "filterable" ? "relation_not_filterable" : "relation_not_selectable",
+		source: input.source.publicName,
+		path: input.fieldPath,
+		relation: input.relationName
+	});
+	if (input.requestedDepth > input.relation.maxDepth) input.issues.push({
+		code: "relation_depth_exceeded",
+		source: input.source.publicName,
+		path: input.fieldPath,
+		relation: input.relationName,
+		requestedDepth: input.requestedDepth,
+		maxDepth: input.relation.maxDepth
+	});
+};
+const validateFieldCapability = (input) => {
+	if (input.field[input.fieldCapability]) return;
+	input.issues.push({
+		code: fieldCapabilityIssueCode[input.fieldCapability],
+		source: input.source.publicName,
+		path: input.fieldPath,
+		field: input.field.publicName
+	});
+};
+const fieldCapabilityIssueCode = {
+	selectable: "field_not_selectable",
+	filterable: "field_not_filterable",
+	sortable: "field_not_sortable",
+	groupable: "field_not_groupable"
+};
+
+//#endregion
+//#region src/query/lower.ts
+const lowerQuerySpecToIREffect = Effect.fn("lowerQuerySpecToIR")(function* (input) {
+	const query = yield* validateQuerySpecEffect(input);
+	const registry = ResolvedRegistrySchema.parse(input.registry);
+	const source = registry.sources[query.source];
+	const joins = /* @__PURE__ */ new Map();
+	const context = {
+		registry,
+		joins
+	};
+	const where = query.where === void 0 ? void 0 : lowerFilter(context, source, query.where);
+	const select = query.select.map((fieldPath) => lowerFieldPath(context, source, fieldPath));
+	const groupBy = (query.groupBy ?? []).map((fieldPath) => lowerFieldPath(context, source, fieldPath));
+	const orderBy = (query.orderBy ?? []).map((orderBy$1) => ({
+		field: lowerFieldPath(context, source, orderBy$1.field),
+		direction: orderBy$1.direction
+	}));
+	return {
+		kind: "select",
+		source: sourceRef(source),
+		select,
+		joins: [...joins.values()],
+		...where === void 0 ? {} : { where },
+		groupBy,
+		orderBy,
+		...query.limit === void 0 ? {} : { limit: query.limit },
+		...query.offset === void 0 ? {} : { offset: query.offset }
+	};
+});
+const lowerQuerySpecToIR = (input) => unwrapLowerQuerySpecResult(Effect.runSync(Effect.either(lowerQuerySpecToIREffect(input))));
+const lowerQuerySpecToIRPromise = async (input) => unwrapLowerQuerySpecResult(await Effect.runPromise(Effect.either(lowerQuerySpecToIREffect(input))));
+const unwrapLowerQuerySpecResult = (result) => {
+	if (result._tag === "Left") throw result.left;
+	return result.right;
+};
+const lowerFilter = (context, source, filter) => {
+	if ("and" in filter) return { and: filter.and.map((child) => lowerFilter(context, source, child)) };
+	if ("or" in filter) return { or: filter.or.map((child) => lowerFilter(context, source, child)) };
+	return {
+		field: lowerFieldPath(context, source, filter.field),
+		op: filter.op,
+		...filter.value === void 0 ? {} : { value: filter.value }
+	};
+};
+const lowerFieldPath = (context, source, fieldPath) => {
+	const parts = fieldPath.split(".");
+	const fieldName = parts.at(-1);
+	const relationNames = parts.slice(0, -1);
+	let currentSource = source;
+	const joinPathParts = [];
+	for (const relationName of relationNames) {
+		const relation = currentSource.relations[relationName];
+		const targetSource = context.registry.sources[relation.target];
+		joinPathParts.push(relationName);
+		const joinPath = joinPathParts.join(".");
+		if (!context.joins.has(joinPath)) context.joins.set(joinPath, {
+			path: joinPath,
+			relation: {
+				publicName: relation.publicName,
+				physicalRelation: relation.physicalRelation
+			},
+			kind: relation.kind,
+			from: sourceRef(currentSource),
+			to: sourceRef(targetSource),
+			localFields: relation.localFields,
+			foreignFields: relation.foreignFields
+		});
+		currentSource = targetSource;
+	}
+	const field = currentSource.fields[fieldName];
+	return {
+		path: fieldPath,
+		source: {
+			publicName: currentSource.publicName,
+			physicalSource: field.physicalSource
+		},
+		field: {
+			publicName: field.publicName,
+			physicalField: field.physicalField
+		},
+		type: field.type,
+		nullable: field.nullable
+	};
+};
+const sourceRef = (source) => ({
+	publicName: source.publicName,
+	physicalSource: source.physicalSource
+});
+
+//#endregion
+//#region src/compiler/sql/dialects/mysql.ts
+const mysqlDialectCompiler = {
+	dialect: "mysql",
+	quoteIdentifier: (identifier) => `\`${identifier.replaceAll("`", "``")}\``,
+	placeholder: () => "?",
+	likeEscapeSql: " escape '\\\\'"
+};
+
+//#endregion
+//#region src/compiler/sql/dialects/postgres.ts
+const postgresDialectCompiler = {
+	dialect: "postgres",
+	quoteIdentifier: (identifier) => `"${identifier.replaceAll("\"", "\"\"")}"`,
+	placeholder: (index) => `$${index}`,
+	likeEscapeSql: " escape '\\'"
+};
+
+//#endregion
+//#region src/compiler/sql/dialects/sqlite.ts
+const sqliteDialectCompiler = {
+	dialect: "sqlite",
+	quoteIdentifier: (identifier) => `"${identifier.replaceAll("\"", "\"\"")}"`,
+	placeholder: () => "?",
+	likeEscapeSql: " escape '\\'"
+};
+
+//#endregion
+//#region src/compiler/sql/index.ts
+const compileQuerySpecToSQLEffect = Effect.fn("compileQuerySpecToSQL")(function* (input) {
+	return compileIRToSQL(yield* lowerQuerySpecToIREffect(input), dialectCompilerFor(input.dialect ?? "mysql"));
+});
+const compileQuerySpecToSQL = (input) => unwrapCompileQuerySpecToSQLResult(Effect.runSync(Effect.either(compileQuerySpecToSQLEffect(input))));
+const compileQuerySpecToSQLPromise = async (input) => unwrapCompileQuerySpecToSQLResult(await Effect.runPromise(Effect.either(compileQuerySpecToSQLEffect(input))));
+const dialectCompilers = {
+	mysql: mysqlDialectCompiler,
+	postgres: postgresDialectCompiler,
+	sqlite: sqliteDialectCompiler
+};
+const dialectCompilerFor = (dialect) => dialectCompilers[dialect];
+const unwrapCompileQuerySpecToSQLResult = (result) => {
+	if (result._tag === "Left") throw result.left;
+	return result.right;
+};
+const compileIRToSQL = (ir, compiler) => {
+	const context = {
+		compiler,
+		params: [],
+		aliasesByPath: new Map([["", "t0"]])
+	};
+	ir.joins.forEach((join, index) => {
+		context.aliasesByPath.set(join.path, `t${index + 1}`);
+	});
+	const sqlParts = [
+		compileSelect(ir, context),
+		`from ${quoteIdentifier(context, ir.source.physicalSource)} as ${quoteIdentifier(context, "t0")}`,
+		...ir.joins.map((join) => {
+			const fromAlias = aliasForPath(context, parentPath(join.path));
+			const toAlias = aliasForPath(context, join.path);
+			const on = join.localFields.map((localField, index) => `${quoteIdentifier(context, fromAlias)}.${quoteIdentifier(context, localField)} = ${quoteIdentifier(context, toAlias)}.${quoteIdentifier(context, join.foreignFields[index])}`).join(" and ");
+			return `left join ${quoteIdentifier(context, join.to.physicalSource)} as ${quoteIdentifier(context, toAlias)} on ${on}`;
+		}),
+		...ir.where === void 0 ? [] : [`where ${compileFilter(context, ir.where)}`],
+		...ir.groupBy.length === 0 ? [] : [`group by ${ir.groupBy.map((field) => compileFieldRef(context, field)).join(", ")}`],
+		...ir.orderBy.length === 0 ? [] : [`order by ${ir.orderBy.map((orderBy) => `${compileFieldRef(context, orderBy.field)} ${orderBy.direction}`).join(", ")}`],
+		...ir.limit === void 0 ? [] : [`limit ${addParam(context, ir.limit)}`],
+		...ir.offset === void 0 ? [] : [`offset ${addParam(context, ir.offset)}`]
+	];
+	return {
+		dialect: compiler.dialect,
+		sql: sqlParts.join("\n"),
+		params: context.params
+	};
+};
+const compileSelect = (ir, context) => `select ${ir.select.map((field) => `${compileFieldRef(context, field)} as ${quoteIdentifier(context, field.path)}`).join(", ")}`;
+const compileFilter = (context, filter) => {
+	if ("and" in filter) return filter.and.map((child) => `(${compileFilter(context, child)})`).join(" and ");
+	if ("or" in filter) return filter.or.map((child) => `(${compileFilter(context, child)})`).join(" or ");
+	return compilePredicate(context, filter.field, filter.op, filter.value);
+};
+const compilePredicate = (context, field, operator, value) => {
+	const fieldRef = compileFieldRef(context, field);
+	switch (operator) {
+		case "eq":
+			if (value === null) return `${fieldRef} is null`;
+			return `${fieldRef} = ${addParam(context, value ?? null)}`;
+		case "neq":
+			if (value === null) return `${fieldRef} is not null`;
+			return `${fieldRef} <> ${addParam(context, value ?? null)}`;
+		case "gt": return `${fieldRef} > ${addParam(context, value ?? null)}`;
+		case "gte": return `${fieldRef} >= ${addParam(context, value ?? null)}`;
+		case "lt": return `${fieldRef} < ${addParam(context, value ?? null)}`;
+		case "lte": return `${fieldRef} <= ${addParam(context, value ?? null)}`;
+		case "in": return `${fieldRef} in (${compileInList(context, value)})`;
+		case "contains": return `${fieldRef} like ${addParam(context, `%${escapeLikePattern(stringValue(value))}%`)}${context.compiler.likeEscapeSql}`;
+		case "startsWith": return `${fieldRef} like ${addParam(context, `${escapeLikePattern(stringValue(value))}%`)}${context.compiler.likeEscapeSql}`;
+		case "endsWith": return `${fieldRef} like ${addParam(context, `%${escapeLikePattern(stringValue(value))}`)}${context.compiler.likeEscapeSql}`;
+		case "isNull": return `${fieldRef} is null`;
+		case "isNotNull": return `${fieldRef} is not null`;
+	}
+};
+const compileInList = (context, value) => {
+	if (!Array.isArray(value) || value.length === 0) return "null";
+	return value.map((item) => addParam(context, item)).join(", ");
+};
+const compileFieldRef = (context, field) => {
+	return `${quoteIdentifier(context, aliasForPath(context, parentPath(field.path)))}.${quoteIdentifier(context, field.field.physicalField)}`;
+};
+const addParam = (context, value) => {
+	context.params.push(value);
+	return context.compiler.placeholder(context.params.length);
+};
+const aliasForPath = (context, path) => context.aliasesByPath.get(path);
+const parentPath = (path) => {
+	const parts = path.split(".");
+	parts.pop();
+	return parts.join(".");
+};
+const quoteIdentifier = (context, identifier) => context.compiler.quoteIdentifier(identifier);
+const stringValue = (value) => {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+};
+const escapeLikePattern = (value) => value.replaceAll(/([\\%_])/g, "\\$1");
+
+//#endregion
+//#region src/results/schema.ts
+const buildQueryIRRowSchema = (ir) => {
+	const shape = {};
+	for (const field of ir.select) shape[field.path] = fieldSchemaForOutput(field);
+	return z.object(shape).strict();
+};
+const buildQueryIRResultSchema = (ir) => z.array(buildQueryIRRowSchema(ir));
+const parseQueryIRResultRows = (ir, rows) => buildQueryIRResultSchema(ir).parse(rows);
+const safeParseQueryIRResultRows = (ir, rows) => buildQueryIRResultSchema(ir).safeParse(rows);
+const fieldSchemaForOutput = (field) => {
+	const schema = fieldTypeSchema(field.type);
+	if (field.nullable || isRelationPath(field.path)) return schema.nullable();
+	return schema;
+};
+const fieldTypeSchema = (type) => {
+	switch (type) {
+		case "string":
+		case "enum": return z.string();
+		case "number": return z.number();
+		case "boolean": return z.boolean();
+		case "date":
+		case "datetime": return z.union([z.string(), z.date()]);
+		case "json": return JsonValueSchema;
+		case "unknown": return z.unknown();
+	}
+};
+const isRelationPath = (path) => path.includes(".");
+
+//#endregion
+//#region src/runtime.ts
+const createQueryRuntime = (input) => {
+	async function run(runInput) {
+		const registry = await resolveRegistryPromise({
+			physical: input.physicalRegistry,
+			...input.defaults === void 0 ? {} : { defaults: input.defaults },
+			...input.policy === void 0 ? {} : { policy: input.policy },
+			...input.policies === void 0 ? {} : { policies: input.policies }
+		});
+		const queryInput = {
+			query: runInput.spec,
+			registry,
+			params: runInput.params
+		};
+		const ir = await lowerQuerySpecToIRPromise(queryInput);
+		const sqlPlan = await compileQuerySpecToSQLPromise({
+			...queryInput,
+			...input.dialect === void 0 ? {} : { dialect: input.dialect }
+		});
+		const rows = parseQueryIRResultRows(ir, await input.executor({
+			db: input.db,
+			plan: sqlPlan
+		}));
+		if (runInput.explain === true) return {
+			rows,
+			explain: {
+				registry,
+				ir,
+				sqlPlan
+			}
+		};
+		return { rows };
+	}
+	return { run };
+};
+
+//#endregion
+//#region src/index.ts
+const queryKitVersion = "0.0.2-alpha.0";
+
+//#endregion
+export { safeParseRegistryDefaults as $, FieldTypeSchema as A, RelationKindSchema as B, resolveRegistryEffect as C, ExposureModeSchema as D, AggregationSchema as E, PhysicalSourceSchema as F, ResolvedSourceSchema as G, ResolvedFieldSchema as H, RegistryDefaultsSchema as I, parsePhysicalRegistry as J, SourceDefaultsSchema as K, RegistryPolicySchema as L, PhysicalRegistrySchema as M, PhysicalRelationSchema as N, FieldDefaultsSchema as O, PhysicalSourceKindSchema as P, safeParsePhysicalRegistry as Q, RegistryVersionSchema as R, resolveRegistry as S, AdapterMetaSchema as T, ResolvedRegistrySchema as U, RelationPolicySchema as V, ResolvedRelationSchema as W, parseRegistryPolicy as X, parseRegistryDefaults as Y, parseResolvedRegistry as Z, validateQuerySpecEffect as _, parseQueryIRResultRows as a, QueryOrderBySchema as at, RegistryResolutionError as b, compileQuerySpecToSQLEffect as c, QuerySortDirectionSchema as ct, lowerQuerySpecToIREffect as d, parseQuerySpec as dt, safeParseRegistryPolicy as et, lowerQuerySpecToIRPromise as f, safeParseQuerySpec as ft, validateQuerySpec as g, QueryValidationIssueSchema as h, buildQueryIRRowSchema as i, QueryFilterSchema as it, PhysicalFieldSchema as j, FieldPolicySchema as k, compileQuerySpecToSQLPromise as l, QuerySpecSchema as lt, QueryValidationError as m, createQueryRuntime as n, JsonValueSchema as nt, safeParseQueryIRResultRows as o, QueryParamRefSchema as ot, QueryParseError as p, SourcePolicySchema as q, buildQueryIRResultSchema as r, QueryFilterOperatorSchema as rt, compileQuerySpecToSQL as s, QueryParamsSchema as st, queryKitVersion as t, safeParseResolvedRegistry as tt, lowerQuerySpecToIR as u, QueryVersionSchema as ut, validateQuerySpecPromise as v, resolveRegistryPromise as w, RegistryResolutionIssueSchema as x, RegistryParseError as y, RelationDefaultsSchema as z };
+//# sourceMappingURL=src-DGGMT7nT.js.map