@mettlecast/domain-cli 0.2.0

package/dist/templates/patterns/flow/autonomous-remediation.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Autonomous-remediation flow pattern template.
+ * Produces: flow that detects anomalies and self-heals without human intervention.
+ */
+export declare function autonomousRemediationTemplate(domain: string, id: string): string;

package/dist/templates/patterns/flow/autonomous-remediation.js

@@ -0,0 +1,98 @@
+/**
+ * Autonomous-remediation flow pattern template.
+ * Produces: flow that detects anomalies and self-heals without human intervention.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function autonomousRemediationTemplate(domain, id) {
+    const varName = camelCase(id);
+    return `import { defineFlow } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Autonomous remediation flow.
+ *
+ * Detects anomaly events, runs diagnostic checks, applies
+ * corrective actions, and verifies resolution — all automated.
+ */
+export const ${varName} = defineFlow({
+  id: '${id}',
+  owningDomain: '${domain}',
+  type: 'standard',
+  name: '${id}',
+  steps: [
+    {
+      type: 'domain-action',
+      name: 'DetectAnomaly',
+      domainId: '${domain}',
+      actionId: 'detect-anomaly',
+      next: 'RunDiagnostics',
+    },
+    {
+      type: 'domain-action',
+      name: 'RunDiagnostics',
+      domainId: '${domain}',
+      actionId: 'run-diagnostics',
+      next: 'DecideAction',
+    },
+    {
+      type: 'choice',
+      name: 'DecideAction',
+      choices: [
+        { when: '$.diagnostics.severity == "critical"', next: 'ApplyCriticalFix' },
+        { when: '$.diagnostics.severity == "warning"', next: 'ApplySoftFix' },
+        { default: true, next: 'LogAndSkip' },
+      ],
+    },
+    {
+      type: 'domain-action',
+      name: 'ApplyCriticalFix',
+      domainId: '${domain}',
+      actionId: 'apply-critical-fix',
+      next: 'VerifyResolution',
+    },
+    {
+      type: 'domain-action',
+      name: 'ApplySoftFix',
+      domainId: '${domain}',
+      actionId: 'apply-soft-fix',
+      next: 'VerifyResolution',
+    },
+    {
+      type: 'domain-action',
+      name: 'LogAndSkip',
+      domainId: '${domain}',
+      actionId: 'log-and-skip',
+      next: 'Done',
+    },
+    {
+      type: 'domain-action',
+      name: 'VerifyResolution',
+      domainId: '${domain}',
+      actionId: 'verify-resolution',
+      next: 'EscalateIfUnresolved',
+    },
+    {
+      type: 'choice',
+      name: 'EscalateIfUnresolved',
+      choices: [
+        { when: '$.resolution === "unresolved"', next: 'EscalateToHuman' },
+        { default: true, next: 'Done' },
+      ],
+    },
+    {
+      type: 'domain-action',
+      name: 'EscalateToHuman',
+      domainId: '${domain}',
+      actionId: 'escalate-to-human',
+      next: 'Done',
+    },
+    {
+      type: 'flow-control',
+      control: 'succeed',
+      name: 'Done',
+    },
+  ],
+});
+`;
+}

package/dist/templates/patterns/flow/fan-out-reaction.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fan-out-reaction flow pattern template.
+ * Produces: flow that fans out an event to multiple domain actions in parallel.
+ */
+export declare function fanOutReactionTemplate(domain: string, id: string): string;

package/dist/templates/patterns/flow/fan-out-reaction.js

@@ -0,0 +1,53 @@
+/**
+ * Fan-out-reaction flow pattern template.
+ * Produces: flow that fans out an event to multiple domain actions in parallel.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function fanOutReactionTemplate(domain, id) {
+    const varName = camelCase(id);
+    return `import { defineFlow } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Fan-out reaction flow.
+ *
+ * When an upstream event arrives, this flow fans out to multiple
+ * domain actions that run in parallel, then joins at a completion step.
+ */
+export const ${varName} = defineFlow({
+  id: '${id}',
+  owningDomain: '${domain}',
+  type: 'express',
+  name: '${id}',
+  steps: [
+    {
+      type: 'domain-action',
+      name: 'NotifyServiceA',
+      domainId: '${domain}',
+      actionId: 'notify-service-a',
+      next: 'NotifyServiceB',
+    },
+    {
+      type: 'domain-action',
+      name: 'NotifyServiceB',
+      domainId: '${domain}',
+      actionId: 'notify-service-b',
+      next: 'AuditFanOut',
+    },
+    {
+      type: 'domain-action',
+      name: 'AuditFanOut',
+      domainId: '${domain}',
+      actionId: 'audit-fan-out',
+      next: 'Done',
+    },
+    {
+      type: 'flow-control',
+      control: 'succeed',
+      name: 'Done',
+    },
+  ],
+});
+`;
+}

package/dist/templates/patterns/flow/human-in-loop.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Human-in-loop flow pattern template.
+ * Produces: flow that pauses for human approval before proceeding.
+ */
+export declare function humanInLoopTemplate(domain: string, id: string): string;

package/dist/templates/patterns/flow/human-in-loop.js

@@ -0,0 +1,90 @@
+/**
+ * Human-in-loop flow pattern template.
+ * Produces: flow that pauses for human approval before proceeding.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function humanInLoopTemplate(domain, id) {
+    const varName = camelCase(id);
+    return `import { defineFlow } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Human-in-the-loop flow.
+ *
+ * Pauses execution at an approval gate, waits for an authorised
+ * human to approve or reject, then proceeds or aborts accordingly.
+ */
+export const ${varName} = defineFlow({
+  id: '${id}',
+  owningDomain: '${domain}',
+  type: 'standard',
+  name: '${id}',
+  steps: [
+    {
+      type: 'domain-action',
+      name: 'PrepareChangeRequest',
+      domainId: '${domain}',
+      actionId: 'prepare-change-request',
+      next: 'NotifyReviewers',
+    },
+    {
+      type: 'domain-action',
+      name: 'NotifyReviewers',
+      domainId: '${domain}',
+      actionId: 'notify-reviewers',
+      next: 'WaitForApproval',
+    },
+    {
+      type: 'domain-action',
+      name: 'WaitForApproval',
+      domainId: '${domain}',
+      actionId: 'wait-for-approval',
+      next: 'EvaluateApproval',
+    },
+    {
+      type: 'choice',
+      name: 'EvaluateApproval',
+      choices: [
+        { when: '$.approval.decision === "approved"', next: 'ApplyChange' },
+        { when: '$.approval.decision === "rejected"', next: 'LogRejection' },
+        { default: true, next: 'RetryApproval' },
+      ],
+    },
+    {
+      type: 'domain-action',
+      name: 'ApplyChange',
+      domainId: '${domain}',
+      actionId: 'apply-change',
+      next: 'NotifyCompletion',
+    },
+    {
+      type: 'domain-action',
+      name: 'LogRejection',
+      domainId: '${domain}',
+      actionId: 'log-rejection',
+      next: 'Done',
+    },
+    {
+      type: 'domain-action',
+      name: 'RetryApproval',
+      domainId: '${domain}',
+      actionId: 'retry-approval',
+      next: 'NotifyReviewers',
+    },
+    {
+      type: 'domain-action',
+      name: 'NotifyCompletion',
+      domainId: '${domain}',
+      actionId: 'notify-completion',
+      next: 'Done',
+    },
+    {
+      type: 'flow-control',
+      control: 'succeed',
+      name: 'Done',
+    },
+  ],
+});
+`;
+}

package/dist/templates/patterns/flow/multi-step-orchestration.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Multi-step-orchestration flow pattern template.
+ * Produces: flow that orchestrates a chain of dependent domain actions.
+ */
+export declare function multiStepOrchestrationTemplate(domain: string, id: string): string;

package/dist/templates/patterns/flow/multi-step-orchestration.js

@@ -0,0 +1,67 @@
+/**
+ * Multi-step-orchestration flow pattern template.
+ * Produces: flow that orchestrates a chain of dependent domain actions.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function multiStepOrchestrationTemplate(domain, id) {
+    const varName = camelCase(id);
+    return `import { defineFlow } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Multi-step orchestration flow.
+ *
+ * Executes a sequential pipeline of domain actions where each step
+ * depends on the output of the previous step.
+ */
+export const ${varName} = defineFlow({
+  id: '${id}',
+  owningDomain: '${domain}',
+  type: 'standard',
+  name: '${id}',
+  steps: [
+    {
+      type: 'domain-action',
+      name: 'ValidateInput',
+      domainId: '${domain}',
+      actionId: 'validate-input',
+      next: 'ProvisionResource',
+    },
+    {
+      type: 'domain-action',
+      name: 'ProvisionResource',
+      domainId: '${domain}',
+      actionId: 'provision-resource',
+      next: 'ConfigureResource',
+    },
+    {
+      type: 'domain-action',
+      name: 'ConfigureResource',
+      domainId: '${domain}',
+      actionId: 'configure-resource',
+      next: 'ActivateResource',
+    },
+    {
+      type: 'domain-action',
+      name: 'ActivateResource',
+      domainId: '${domain}',
+      actionId: 'activate-resource',
+      next: 'SendNotification',
+    },
+    {
+      type: 'domain-action',
+      name: 'SendNotification',
+      domainId: '${domain}',
+      actionId: 'send-notification',
+      next: 'Done',
+    },
+    {
+      type: 'flow-control',
+      control: 'succeed',
+      name: 'Done',
+    },
+  ],
+});
+`;
+}

package/dist/templates/patterns/hook/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Paginated list hook pattern — uses `useInfiniteQuery` from TanStack Query for paginated lists.
+ */
+export declare function paginatedListHookTemplate(name: string): string;
+export declare function mutationHookTemplate(name: string): string;
+export declare function featureFlagHookTemplate(name: string): string;
+export declare function subscriptionHookTemplate(name: string): string;