@zodmire/config 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Vercel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/mod.d.mts

@@ -0,0 +1,317 @@
+import { z } from "zod";
+
+//#region packages/config/codegen_meta.d.ts
+type CommandEffect = {
+  kind: "set-field" | "raise-event" | "increment" | "decrement" | "push-to-collection";
+  target: string;
+  value?: string;
+};
+type InvariantRule = {
+  name: string;
+  rule: string;
+  errorType: string;
+  errorMessage: string;
+};
+type AggregateMeta = {
+  kind: "aggregate";
+  tableName: string;
+  idField: string;
+  idType?: string;
+  invariants?: InvariantRule[];
+};
+type EntityMeta = {
+  kind: "entity";
+  tableName?: string;
+  idField: string;
+  idType?: string;
+};
+type ValueObjectMeta = {
+  kind: "value-object";
+};
+type CommandInputMeta = {
+  kind: "command-input";
+  commandName: string;
+  targetAggregate: string;
+  commandKind: "create" | "update";
+  lifecycle?: "create" | "mutate";
+  loadBy?: string;
+  preconditions?: string[];
+  emits?: string[];
+  effects?: CommandEffect[];
+};
+type FilterOperator = "eq" | "in" | "gt" | "gte" | "lt" | "lte" | "contains" | "startsWith";
+type ComputedFieldSpec = {
+  kind: "builtin";
+  source: "children";
+  collection: string;
+  fn: "count" | "exists";
+} | {
+  kind: "builtin";
+  source: "children";
+  collection: string;
+  field: string;
+  fn: "sum" | "min" | "max";
+} | {
+  kind: "custom";
+};
+type FindByIdQueryInputMeta = {
+  kind: "query-input";
+  queryKind: "findById";
+  queryName: string;
+  targetAggregate: string;
+  readSide: {
+    readModelName: string;
+  };
+};
+type ListQueryInputMeta = {
+  kind: "query-input";
+  queryKind: "list";
+  queryName: string;
+  targetAggregate: string;
+  readSide: {
+    readModelName: string;
+    searchFields?: string[];
+  };
+  pagination: {
+    style: "offset";
+  } | {
+    style: "cursor";
+  };
+  filters: Record<string, FilterOperator[]>;
+  sorting: {
+    sortableFields: string[];
+    defaultSort: {
+      field: string;
+      direction: "asc" | "desc";
+    };
+  };
+};
+type QueryInputMeta = FindByIdQueryInputMeta | ListQueryInputMeta;
+type QueryOutputMeta = {
+  kind: "query-output";
+  queryName: string;
+};
+type ReadModelIndexMeta = {
+  name: string;
+  fields: string[];
+};
+type ReadModelUniqueConstraintMeta = {
+  name: string;
+  fields: string[];
+};
+type ReadModelMeta = {
+  kind: "read-model";
+  readModelName: string;
+  ownerContext: string;
+  ownerAggregate: string;
+  tableName: string;
+  primaryKey: string[];
+  indexes?: ReadModelIndexMeta[];
+  uniqueConstraints?: ReadModelUniqueConstraintMeta[];
+  servesQueries?: string[];
+};
+type ProjectionValueSourceMeta = {
+  kind: "event-field";
+  field: string;
+} | {
+  kind: "literal";
+  value: string | number | boolean | null;
+} | {
+  kind: "expression";
+  expression: string;
+};
+type ProjectionMutationMeta = {
+  kind: "upsert";
+  matchOn: string[];
+  set?: Record<string, ProjectionValueSourceMeta>;
+} | {
+  kind: "delete";
+  matchOn: string[];
+} | {
+  kind: "custom";
+  handlerName: string;
+};
+type ProjectionSourceMeta = {
+  role: "primary" | "enrichment";
+  contextName: string;
+  aggregateName: string;
+  eventName: string;
+  mutation: ProjectionMutationMeta;
+};
+type ProjectionRebuildMeta = {
+  enabled: false;
+} | {
+  enabled: true;
+  strategy: "full-replay";
+  batchSize?: number;
+};
+type ProjectionSubscriptionMeta = {
+  subscriptionName?: string;
+  consumerGroup?: string;
+};
+type ProjectionMeta = {
+  kind: "projection";
+  projectionName: string;
+  readModelName: string;
+  sources: ProjectionSourceMeta[];
+  rebuild?: ProjectionRebuildMeta;
+  subscription?: ProjectionSubscriptionMeta;
+};
+type DomainEventMeta = {
+  kind: "domain-event";
+};
+type FieldMeta = {
+  kind: "field";
+  columnType?: string;
+  indexed?: boolean;
+};
+type DomainErrorMeta = {
+  kind: "domain-error";
+  invariantName: string;
+  errorTypeName: string;
+  defaultMessage: string;
+};
+type ApplicationErrorMeta = {
+  kind: "application-error";
+  errorTypeName: string;
+  aggregateName: string;
+};
+type CodegenMeta = AggregateMeta | EntityMeta | ValueObjectMeta | CommandInputMeta | QueryInputMeta | QueryOutputMeta | ReadModelMeta | ProjectionMeta | DomainEventMeta | FieldMeta | DomainErrorMeta | ApplicationErrorMeta;
+/**
+ * Creates a Zod v4 registry typed to CodegenMeta.
+ * Attach metadata to any schema with `schema.register(registry, meta)`.
+ * Retrieve with `registry.get(schema)`.
+ */
+declare function createCodegenRegistry(): ReturnType<typeof z.registry<CodegenMeta>>;
+/**
+ * Identity factory for CodegenMeta — validates the shape at the type level
+ * and returns it unchanged. Useful in tests and schema annotations.
+ */
+declare function createCodegenMeta<T extends CodegenMeta>(meta: T): T;
+//#endregion
+//#region packages/config/context_config.d.ts
+declare const ContextConfigSchema: z.ZodObject<{
+  name: z.ZodString;
+  modulePath: z.ZodString;
+  schemaFiles: z.ZodArray<z.ZodString>;
+  ports: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      repository: "repository";
+      service: "service";
+      acl: "acl";
+    }>;
+    target: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  adapters: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    port: z.ZodString;
+    kind: z.ZodEnum<{
+      "drizzle-repository": "drizzle-repository";
+      "external-service": "external-service";
+    }>;
+  }, z.core.$strict>>;
+  acls: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    port: z.ZodString;
+    kind: z.ZodLiteral<"read">;
+    source: z.ZodObject<{
+      context: z.ZodString;
+      query: z.ZodString;
+    }, z.core.$strict>;
+    request: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+      from: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>]>>;
+    response: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+      from: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>]>>;
+  }, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    port: z.ZodString;
+    kind: z.ZodLiteral<"write">;
+    target: z.ZodObject<{
+      context: z.ZodString;
+      command: z.ZodString;
+    }, z.core.$strict>;
+    request: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+      from: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>]>>;
+    response: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+      from: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>]>>;
+  }, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    port: z.ZodString;
+    kind: z.ZodLiteral<"ack">;
+    target: z.ZodObject<{
+      context: z.ZodString;
+      command: z.ZodString;
+    }, z.core.$strict>;
+    request: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+      from: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      const: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    }, z.core.$strict>]>>;
+  }, z.core.$strict>], "kind">>>;
+  presentation: z.ZodObject<{
+    trpcRouter: z.ZodString;
+    procedures: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      kind: z.ZodEnum<{
+        query: "query";
+        command: "command";
+      }>;
+      operation: z.ZodString;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  materialization: z.ZodObject<{
+    targetRoot: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type ContextConfig = z.output<typeof ContextConfigSchema>;
+declare function defineContext(config: unknown): ContextConfig;
+//#endregion
+//#region packages/config/composition_config.d.ts
+declare const SubscriptionSchema: z.ZodObject<{
+  targetContext: z.ZodString;
+  action: z.ZodString;
+}, z.core.$strip>;
+declare const CrossContextEventSchema: z.ZodObject<{
+  eventType: z.ZodString;
+  sourceContext: z.ZodString;
+  payloadSchema: z.ZodAny;
+  subscriptions: z.ZodArray<z.ZodObject<{
+    targetContext: z.ZodString;
+    action: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const CompositionConfigSchema: z.ZodObject<{
+  name: z.ZodString;
+  contexts: z.ZodArray<z.ZodString>;
+  crossContextEvents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    eventType: z.ZodString;
+    sourceContext: z.ZodString;
+    payloadSchema: z.ZodAny;
+    subscriptions: z.ZodArray<z.ZodObject<{
+      targetContext: z.ZodString;
+      action: z.ZodString;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  materialization: z.ZodObject<{
+    targetRoot: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CompositionConfig = z.infer<typeof CompositionConfigSchema>;
+type CrossContextEvent = z.infer<typeof CrossContextEventSchema>;
+type Subscription = z.infer<typeof SubscriptionSchema>;
+declare function defineComposition(config: z.input<typeof CompositionConfigSchema>): CompositionConfig;
+//#endregion
+export { AggregateMeta, ApplicationErrorMeta, CodegenMeta, CommandEffect, CommandInputMeta, CompositionConfig, CompositionConfigSchema, ComputedFieldSpec, ContextConfig, ContextConfigSchema, CrossContextEvent, DomainErrorMeta, DomainEventMeta, EntityMeta, FieldMeta, FilterOperator, FindByIdQueryInputMeta, InvariantRule, ListQueryInputMeta, ProjectionMeta, ProjectionMutationMeta, ProjectionRebuildMeta, ProjectionSourceMeta, ProjectionSubscriptionMeta, ProjectionValueSourceMeta, QueryInputMeta, QueryOutputMeta, ReadModelIndexMeta, ReadModelMeta, ReadModelUniqueConstraintMeta, Subscription, ValueObjectMeta, createCodegenMeta, createCodegenRegistry, defineComposition, defineContext };

package/mod.mjs

@@ -0,0 +1,126 @@
+import { z } from "zod";
+
+//#region packages/config/codegen_meta.ts
+/**
+* Creates a Zod v4 registry typed to CodegenMeta.
+* Attach metadata to any schema with `schema.register(registry, meta)`.
+* Retrieve with `registry.get(schema)`.
+*/
+function createCodegenRegistry() {
+	return z.registry();
+}
+/**
+* Identity factory for CodegenMeta — validates the shape at the type level
+* and returns it unchanged. Useful in tests and schema annotations.
+*/
+function createCodegenMeta(meta) {
+	return meta;
+}
+
+//#endregion
+//#region packages/config/context_config.ts
+const MappingExprSchema = z.union([z.strictObject({ from: z.string().min(1) }), z.strictObject({ const: z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]) })]);
+const AclSourceSchema = z.strictObject({
+	context: z.string().min(1),
+	query: z.string().min(1)
+});
+const AclTargetSchema = z.strictObject({
+	context: z.string().min(1),
+	command: z.string().min(1)
+});
+const ReadAclSchema = z.strictObject({
+	name: z.string().min(1),
+	port: z.string().min(1),
+	kind: z.literal("read"),
+	source: AclSourceSchema,
+	request: z.record(z.string(), MappingExprSchema),
+	response: z.record(z.string(), MappingExprSchema)
+});
+const WriteAclSchema = z.strictObject({
+	name: z.string().min(1),
+	port: z.string().min(1),
+	kind: z.literal("write"),
+	target: AclTargetSchema,
+	request: z.record(z.string(), MappingExprSchema),
+	response: z.record(z.string(), MappingExprSchema)
+});
+const AckSchema = z.strictObject({
+	name: z.string().min(1),
+	port: z.string().min(1),
+	kind: z.literal("ack"),
+	target: AclTargetSchema,
+	request: z.record(z.string(), MappingExprSchema)
+});
+const PortSchema = z.strictObject({
+	name: z.string().min(1),
+	kind: z.enum([
+		"repository",
+		"service",
+		"acl"
+	]),
+	target: z.string().min(1).optional()
+});
+const AdapterSchema = z.strictObject({
+	name: z.string().min(1),
+	port: z.string().min(1),
+	kind: z.enum(["drizzle-repository", "external-service"])
+});
+const ProcedureSchema = z.strictObject({
+	name: z.string().min(1),
+	kind: z.enum(["command", "query"]),
+	operation: z.string().min(1)
+});
+const PresentationSchema = z.strictObject({
+	trpcRouter: z.string().min(1),
+	procedures: z.array(ProcedureSchema)
+});
+const MaterializationSchema = z.strictObject({ targetRoot: z.string().min(1) });
+const AclSchema = z.discriminatedUnion("kind", [
+	ReadAclSchema,
+	WriteAclSchema,
+	AckSchema
+]);
+const ContextConfigSchema = z.strictObject({
+	name: z.string().min(1),
+	modulePath: z.string().min(1),
+	schemaFiles: z.array(z.string().min(1)).min(1),
+	ports: z.array(PortSchema),
+	adapters: z.array(AdapterSchema),
+	acls: z.array(AclSchema).default([]),
+	presentation: PresentationSchema,
+	materialization: MaterializationSchema
+});
+function defineContext(config) {
+	return ContextConfigSchema.parse(config);
+}
+
+//#endregion
+//#region packages/config/composition_config.ts
+const SubscriptionSchema = z.object({
+	targetContext: z.string().min(1),
+	action: z.string().min(1)
+});
+const CrossContextEventSchema = z.object({
+	eventType: z.string().regex(/^[A-Z][a-zA-Z]+\.[A-Z][a-zA-Z]+$/),
+	sourceContext: z.string().min(1),
+	payloadSchema: z.any(),
+	subscriptions: z.array(SubscriptionSchema).min(1)
+});
+const CompositionMaterializationSchema = z.object({ targetRoot: z.string().min(1) });
+const CompositionConfigSchema = z.object({
+	name: z.string().min(1),
+	contexts: z.array(z.string().min(1)).min(1),
+	crossContextEvents: z.array(CrossContextEventSchema).default([]),
+	materialization: CompositionMaterializationSchema
+});
+function defineComposition(config) {
+	return CompositionConfigSchema.parse(config);
+}
+
+//#endregion
+export { CompositionConfigSchema, ContextConfigSchema, createCodegenMeta, createCodegenRegistry, defineComposition, defineContext };

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@zodmire/config",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "main": "./mod.mjs",
+  "module": "./mod.mjs",
+  "types": "./mod.d.mts",
+  "exports": {
+    ".": {
+      "types": "./mod.d.mts",
+      "import": "./mod.mjs"
+    }
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
+}