@mettlecast/domain-cli 0.2.0

package/dist/templates/patterns/page/wizard.js

@@ -0,0 +1,293 @@
+/**
+ * Wizard page pattern template — multi-step form with progress bar.
+ */
+export function wizardPageTemplate(pageName) {
+    const componentName = `${pageName}Page`;
+    return `import { useState, useCallback } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+import { ArrowLeft, ArrowRight, Check, Save } from 'lucide-react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useTib } from '@/hooks/useTib';
+import { Page } from '@/components/layout/Page';
+import { PageHeader } from '@/components/layout/PageHeader';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Progress } from '@/components/ui/progress';
+import { toast } from 'sonner';
+
+interface ${componentName}Props {
+  workspaceId: string;
+}
+
+/** Steps definition */
+const STEPS = [
+  { id: 'basics', label: 'Basics', description: 'Basic information' },
+  { id: 'details', label: 'Details', description: 'Additional details' },
+  { id: 'review', label: 'Review', description: 'Review and confirm' },
+] as const;
+
+type StepId = (typeof STEPS)[number]['id'];
+
+/** Full form schema across all steps */
+const wizardSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  description: z.string().optional(),
+  type: z.string().min(1, 'Type is required'),
+  status: z.enum(['active', 'inactive']),
+  notes: z.string().optional(),
+});
+
+type WizardValues = z.infer<typeof wizardSchema>;
+
+export function ${componentName}({ workspaceId }: ${componentName}Props) {
+  const tib = useTib();
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const [currentStep, setCurrentStep] = useState<number>(0);
+  const [completedSteps, setCompletedSteps] = useState<Set<number>>(new Set([0]));
+
+  const form = useForm<WizardValues>({
+    resolver: zodResolver(wizardSchema),
+    defaultValues: {
+      name: '',
+      description: '',
+      type: '',
+      status: 'active',
+      notes: '',
+    },
+    mode: 'onChange',
+  });
+
+  const { register, handleSubmit, formState: { errors }, setValue, watch, trigger } = form;
+
+  const mutation = useMutation({
+    mutationFn: (values: WizardValues) =>
+      tib.data.create({ workspaceId, ...values }),
+    onSuccess: () => {
+      toast.success('\${pageName} created successfully');
+      queryClient.invalidateQueries({ queryKey: ['data-list', workspaceId] });
+      navigate('..');
+    },
+    onError: (err) => {
+      toast.error('Failed to create', {
+        description: err instanceof Error ? err.message : 'Unknown error',
+      });
+    },
+  });
+
+  const progress = ((completedSteps.size) / STEPS.length) * 100;
+
+  const isFirstStep = currentStep === 0;
+  const isLastStep = currentStep === STEPS.length - 1;
+
+  const goNext = useCallback(async () => {
+    const fieldsToValidate = getFieldsForStep(currentStep);
+    const valid = await trigger(fieldsToValidate);
+    if (valid) {
+      const next = currentStep + 1;
+      setCompletedSteps(prev => new Set([...prev, next]));
+      setCurrentStep(next);
+    }
+  }, [currentStep, trigger]);
+
+  const goBack = useCallback(() => {
+    setCurrentStep(prev => Math.max(0, prev - 1));
+  }, []);
+
+  const onSubmit = (values: WizardValues) => mutation.mutate(values);
+
+  return (
+    <Page title="Create ${pageName}" description="Follow the steps to create a new entity">
+      <Page.Header
+        breadcrumb={[
+          { label: '${pageName}', to: '..' },
+          { label: 'Create' },
+        ]}
+      />
+      <Page.Body>
+        <div className="max-w-2xl mx-auto">
+          {/* Progress bar */}
+          <div className="mb-8">
+            <Progress value={progress} className="h-2" />
+            <div className="flex justify-between mt-2">
+              {STEPS.map((step, idx) => (
+                <div
+                  key={step.id}
+                  className={[
+                    'flex items-center gap-2 text-sm',
+                    idx <= currentStep ? 'text-primary' : 'text-muted-foreground',
+                  ].join(' ')}
+                >
+                  <span className={[
+                    'flex h-6 w-6 items-center justify-center rounded-full text-xs font-medium',
+                    completedSteps.has(idx)
+                      ? 'bg-primary text-primary-foreground'
+                      : 'border border-muted-foreground text-muted-foreground',
+                  ].join(' ')}>
+                    {completedSteps.has(idx) ? <Check className="h-3 w-3" /> : idx + 1}
+                  </span>
+                  <span className="hidden sm:inline">{step.label}</span>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          <form onSubmit={handleSubmit(onSubmit)} className="space-y-6">
+            {/* Step 1: Basics */}
+            {currentStep === 0 && (
+              <div className="space-y-4">
+                <h2 className="text-lg font-semibold">Basic Information</h2>
+                <div className="space-y-2">
+                  <Label htmlFor="name">Name</Label>
+                  <Input
+                    id="name"
+                    {...register('name')}
+                    placeholder="Enter name"
+                    aria-invalid={!!errors.name}
+                  />
+                  {errors.name && (
+                    <p className="text-xs text-destructive">{errors.name.message}</p>
+                  )}
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="description">Description</Label>
+                  <Textarea
+                    id="description"
+                    {...register('description')}
+                    placeholder="Optional description"
+                    rows={3}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="type">Type</Label>
+                  <Input
+                    id="type"
+                    {...register('type')}
+                    placeholder="Enter type"
+                    aria-invalid={!!errors.type}
+                  />
+                  {errors.type && (
+                    <p className="text-xs text-destructive">{errors.type.message}</p>
+                  )}
+                </div>
+              </div>
+            )}
+
+            {/* Step 2: Details */}
+            {currentStep === 1 && (
+              <div className="space-y-4">
+                <h2 className="text-lg font-semibold">Additional Details</h2>
+                <div className="space-y-2">
+                  <Label htmlFor="wiz-status">Status</Label>
+                  <Select
+                    value={watch('status')}
+                    onValueChange={(value) => setValue('status', value as 'active' | 'inactive')}
+                  >
+                    <SelectTrigger id="wiz-status">
+                      <SelectValue placeholder="Select status" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="active">Active</SelectItem>
+                      <SelectItem value="inactive">Inactive</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="notes">Notes</Label>
+                  <Textarea
+                    id="notes"
+                    {...register('notes')}
+                    placeholder="Add any notes"
+                    rows={3}
+                  />
+                </div>
+              </div>
+            )}
+
+            {/* Step 3: Review */}
+            {currentStep === 2 && (
+              <div className="space-y-4">
+                <h2 className="text-lg font-semibold">Review & Confirm</h2>
+                <div className="rounded-lg border border-border p-4 space-y-3">
+                  <div className="flex justify-between">
+                    <span className="text-sm text-muted-foreground">Name</span>
+                    <span className="text-sm font-medium">{watch('name') || '—'}</span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span className="text-sm text-muted-foreground">Description</span>
+                    <span className="text-sm font-medium">{watch('description') || '—'}</span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span className="text-sm text-muted-foreground">Type</span>
+                    <span className="text-sm font-medium">{watch('type') || '—'}</span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span className="text-sm text-muted-foreground">Status</span>
+                    <span className="text-sm font-medium">{watch('status')}</span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span className="text-sm text-muted-foreground">Notes</span>
+                    <span className="text-sm font-medium">{watch('notes') || '—'}</span>
+                  </div>
+                </div>
+                <p className="text-xs text-muted-foreground">
+                  Review the details above and click &ldquo;Create&rdquo; to finalize.
+                </p>
+              </div>
+            )}
+
+            {/* Navigation buttons */}
+            <div className="flex items-center justify-between pt-4 border-t border-border">
+              <Button
+                type="button"
+                variant="outline"
+                size="sm"
+                onClick={goBack}
+                disabled={isFirstStep}
+              >
+                <ArrowLeft className="h-4 w-4 mr-1" />
+                Back
+              </Button>
+              {!isLastStep ? (
+                <Button type="button" variant="teal" size="sm" onClick={goNext}>
+                  Next
+                  <ArrowRight className="h-4 w-4 ml-1" />
+                </Button>
+              ) : (
+                <Button
+                  type="submit"
+                  variant="teal"
+                  size="sm"
+                  disabled={mutation.isPending}
+                >
+                  <Save className="h-4 w-4 mr-1" />
+                  {mutation.isPending ? 'Creating...' : 'Create'}
+                </Button>
+              )}
+            </div>
+          </form>
+        </div>
+      </Page.Body>
+    </Page>
+  );
+}
+
+/** Returns the field names that belong to each step for validation. */
+function getFieldsForStep(step: number): Array<keyof WizardValues> {
+  switch (step) {
+    case 0: return ['name', 'description', 'type'];
+    case 1: return ['status', 'notes'];
+    case 2: return []; // review step — already valid
+    default: return [];
+  }
+}
+
+export default ${componentName};
+`;
+}

package/dist/templates/patterns/subscriber/audit-relay.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Audit-relay subscriber pattern template.
+ * Produces: subscriber that relays domain events to an audit event-store or external sink.
+ */
+export declare function auditRelayTemplate(domain: string, id: string, event: string): string;

package/dist/templates/patterns/subscriber/audit-relay.js

@@ -0,0 +1,51 @@
+/**
+ * Audit-relay subscriber pattern template.
+ * Produces: subscriber that relays domain events to an audit event-store or external sink.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function auditRelayTemplate(domain, id, event) {
+    const varName = camelCase(id);
+    return `import { defineSubscriber } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Relays ${event} to the audit event-store for compliance.
+ *
+ * Captures every instance of ${event} and stores an immutable
+ * audit record including caller identity, timestamp, and event payload.
+ */
+export const ${varName} = defineSubscriber({
+  id: '${domain}.${id}',
+  event: '${event}',
+  semverRange: '^1',
+  handler: async (event, ctx) => {
+    const auditRecord = {
+      pk: 'AUDIT#' + event.data.tenantId,
+      sk: 'EVENT#' + event.id,
+      eventType: event.type,
+      eventVersion: event.version,
+      payload: event.data,
+      timestamp: event.timestamp,
+      source: event.source,
+      correlationId: event.correlationId,
+      ttl: Math.floor(Date.now() / 1000) + 90 * 86400, // 90-day retention
+    };
+
+    // ── Write to audit store ─────────────────────────────────
+    await ctx.db.put(auditRecord);
+
+    // ── Optionally forward to external sink ──────────────────
+    if (ctx.integrations?.auditSink) {
+      await ctx.fetch(ctx.integrations.auditSink, {
+        method: 'POST',
+        body: JSON.stringify(auditRecord),
+        headers: { 'content-type': 'application/json' },
+      });
+    }
+
+    ctx.metrics?.putMetric('${id}.audit.relayed', 1, 'Count');
+  },
+});
+`;
+}

package/dist/templates/patterns/subscriber/cascade-deletion.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cascade-deletion subscriber pattern template.
+ * Produces: subscriber that deletes related records when a parent is deleted.
+ */
+export declare function cascadeDeletionTemplate(domain: string, id: string, event: string): string;

package/dist/templates/patterns/subscriber/cascade-deletion.js

@@ -0,0 +1,60 @@
+/**
+ * Cascade-deletion subscriber pattern template.
+ * Produces: subscriber that deletes related records when a parent is deleted.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function cascadeDeletionTemplate(domain, id, event) {
+    const varName = camelCase(id);
+    return `import { defineSubscriber } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Cascading deletion triggered by ${event}.
+ *
+ * When a parent ${event} event fires, this subscriber:
+ * 1. Queries for all child records owned by the deleted parent.
+ * 2. Soft-deletes each child (sets deletedAt timestamp).
+ * 3. Emits metrics for observability.
+ */
+export const ${varName} = defineSubscriber({
+  id: '${domain}.${id}',
+  event: '${event}',
+  semverRange: '^1',
+  handler: async (event, ctx) => {
+    const { entityId, tenantId } = event.data;
+
+    // ── Find all children ────────────────────────────────────
+    const children = await ctx.db.query({
+      pk: 'TENANT#' + tenantId,
+      skPrefix: 'CHILD#' + entityId,
+    });
+
+    // ── Soft-delete each child ───────────────────────────────
+    const now = new Date().toISOString();
+    for (const child of children) {
+      await ctx.db.update({
+        key: { pk: child.pk, sk: child.sk },
+        updates: {
+          deletedAt: now,
+          deletedBy: event.data.deletedBy ?? 'system',
+        },
+      });
+    }
+
+    // ── Audit log ────────────────────────────────────────────
+    await ctx.auditLog({
+      action: 'cascade.delete',
+      tenantId,
+      entityId,
+      meta: {
+        childrenDeleted: children.length,
+        triggeredBy: event.id,
+      },
+    });
+
+    ctx.metrics?.putMetric('${id}.cascade.deleted', children.length, 'Count');
+  },
+});
+`;
+}

package/dist/templates/patterns/subscriber/single-step-projection.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Single-step-projection subscriber pattern template.
+ * Produces: subscriber that updates a read-model projection table.
+ */
+export declare function singleStepProjectionTemplate(domain: string, id: string, event: string): string;

package/dist/templates/patterns/subscriber/single-step-projection.js

@@ -0,0 +1,36 @@
+/**
+ * Single-step-projection subscriber pattern template.
+ * Produces: subscriber that updates a read-model projection table.
+ */
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function singleStepProjectionTemplate(domain, id, event) {
+    const varName = camelCase(id);
+    return `import { defineSubscriber } from '@mettlecast/domain-runtime';
+
+/**
+ * ${id} — Projects ${event} events into a read-optimised view.
+ */
+export const ${varName} = defineSubscriber({
+  id: '${domain}.${id}',
+  event: '${event}',
+  semverRange: '^1',
+  handler: async (event, ctx) => {
+    const { tenantId, ...eventData } = event.data;
+
+    // ── Upsert projection ────────────────────────────────────
+    // Each event updates the projection row for fast reads.
+    await ctx.db.put({
+      pk: 'TENANT#' + tenantId,
+      sk: 'PROJECTION#' + event.id,
+      ...eventData,
+      lastEventId: event.id,
+      projectedAt: new Date().toISOString(),
+    });
+
+    ctx.metrics?.putMetric('${id}.projection.applied', 1, 'Count');
+  },
+});
+`;
+}

package/dist/templates/readme.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Template for generating per-domain README.md.
+ */
+export declare function readmeTemplate(id: string): string;

package/dist/templates/readme.js

@@ -0,0 +1,7 @@
+/**
+ * Template for generating per-domain README.md.
+ */
+export function readmeTemplate(id) {
+    const titleName = id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+    return `# ${titleName}\n\n> One-line description of what this domain does — update this.\n\n## Overview\n\nDomain ID: \`${id}\`\n\n## API Endpoints\n\nSee \`domains/${id}/api/\` for all endpoint handlers.\n\n## Events Published\n\nSee \`domains/${id}/publishes/events.ts\` for all published event types.\n\n## Development\n\n\`\`\`bash\nnpx mc-domain-module dev domains/${id}\nnpx mc-domain-module validate domains/${id}\nnpx mc-domain-module build domains/${id}\n\`\`\`\n`;
+}

package/dist/templates/subscriber-skeleton.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Template for generating subscriber handler skeleton.
+ */
+/**
+ * Generates a subscriber handler skeleton.
+ * @param domainId - Domain ID in kebab-case.
+ * @param subscriberId - Subscriber ID in kebab-case.
+ * @param eventId - Event ID to subscribe to (e.g. 'domain.event').
+ * @returns TypeScript source code as a string.
+ */
+export declare function subscriberSkeletonTemplate(domainId: string, subscriberId: string, eventId: string): string;

package/dist/templates/subscriber-skeleton.js

@@ -0,0 +1,23 @@
+/**
+ * Template for generating subscriber handler skeleton.
+ */
+/**
+ * Generates a subscriber handler skeleton.
+ * @param domainId - Domain ID in kebab-case.
+ * @param subscriberId - Subscriber ID in kebab-case.
+ * @param eventId - Event ID to subscribe to (e.g. 'domain.event').
+ * @returns TypeScript source code as a string.
+ */
+export function subscriberSkeletonTemplate(domainId, subscriberId, eventId) {
+    return `import { defineSubscriber } from '../../../lib/domain-runtime';
+
+export const ${subscriberId.replace(/-([a-z])/g, (_, c) => c.toUpperCase())} = defineSubscriber({
+  id: '${domainId}.${subscriberId}',
+  event: '${eventId}',
+  semverRange: '*',
+  handler: async (_event, _ctx) => {
+    // TODO: Implement subscriber handler
+  },
+});
+`;
+}

package/dist/utils/checksum.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compute SHA-256 checksum of a Buffer, returning a lowercase hex string.
+ */
+export declare function computeChecksumBuffer(buf: Buffer): string;
+/**
+ * Compute SHA-256 checksum of a string (encoded as UTF-8), returning a lowercase hex string.
+ */
+export declare function computeChecksumString(content: string): string;
+/**
+ * Compute SHA-256 checksum of a file on disk, returning a lowercase hex string.
+ * Returns null if the file does not exist.
+ */
+export declare function computeChecksumFile(filePath: string): Promise<string | null>;
+/**
+ * Returns true if the file on disk has been modified compared to the expected checksum.
+ * Returns false if the checksums match, or null if the file does not exist.
+ */
+export declare function isDrifted(filePath: string, expectedChecksum: string): Promise<boolean | null>;

package/dist/utils/checksum.js

@@ -0,0 +1,39 @@
+import { createHash } from 'crypto';
+import { readFile } from 'fs/promises';
+/**
+ * Compute SHA-256 checksum of a Buffer, returning a lowercase hex string.
+ */
+export function computeChecksumBuffer(buf) {
+    return createHash('sha256').update(buf).digest('hex');
+}
+/**
+ * Compute SHA-256 checksum of a string (encoded as UTF-8), returning a lowercase hex string.
+ */
+export function computeChecksumString(content) {
+    return createHash('sha256').update(content, 'utf-8').digest('hex');
+}
+/**
+ * Compute SHA-256 checksum of a file on disk, returning a lowercase hex string.
+ * Returns null if the file does not exist.
+ */
+export async function computeChecksumFile(filePath) {
+    try {
+        const buf = await readFile(filePath);
+        return computeChecksumBuffer(buf);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+/**
+ * Returns true if the file on disk has been modified compared to the expected checksum.
+ * Returns false if the checksums match, or null if the file does not exist.
+ */
+export async function isDrifted(filePath, expectedChecksum) {
+    const actual = await computeChecksumFile(filePath);
+    if (actual === null)
+        return null;
+    return actual !== expectedChecksum;
+}

package/dist/utils/file-helpers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Maps each convention slot to the absolute file paths found for that slot.
+ * For the 'domain' slot there is exactly one path (domain.config.ts).
+ * For the 'publishes' slot there is exactly one path (publishes/events.ts).
+ * All other slots may have 0..N paths.
+ */
+export interface DomainFilePaths {
+    /** Path to domain.config.ts if present. */
+    domain: string | undefined;
+    /** API handler file paths under api/. */
+    apis: string[];
+    /** Webhook handler file paths under webhooks/. */
+    webhooks: string[];
+    /** Subscriber handler file paths under subscribers/. */
+    subscribers: string[];
+    /** Action handler file paths under actions/. */
+    actions: string[];
+    /** Schedule handler file paths under schedules/. */
+    schedules: string[];
+    /** Job handler file paths under jobs/. */
+    jobs: string[];
+    /** Integration definition file paths under integrations/. */
+    integrations: string[];
+    /** Path to publishes/events.ts if present. */
+    publishes: string | undefined;
+}
+/**
+ * Walk a domain root directory and return the conventional file paths for each primitive slot.
+ * Only returns files with a `.ts` extension. Recurses into subdirectories but skips
+ * node_modules, __tests__, and dist directories.
+ * Returns undefined for slots where no files are found (domain.config.ts, publishes/events.ts).
+ * @param domainRoot - Absolute path to the domain directory (e.g. `.mc/domains/billing`).
+ * @returns DomainFilePaths with absolute paths.
+ */
+export declare function walkDomainDir(domainRoot: string): Promise<DomainFilePaths>;

package/dist/utils/file-helpers.js

@@ -0,0 +1,59 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Walk a domain root directory and return the conventional file paths for each primitive slot.
+ * Only returns files with a `.ts` extension. Recurses into subdirectories but skips
+ * node_modules, __tests__, and dist directories.
+ * Returns undefined for slots where no files are found (domain.config.ts, publishes/events.ts).
+ * @param domainRoot - Absolute path to the domain directory (e.g. `.mc/domains/billing`).
+ * @returns DomainFilePaths with absolute paths.
+ */
+export async function walkDomainDir(domainRoot) {
+    async function tsFiles(dir) {
+        const result = [];
+        async function walk(current) {
+            try {
+                const entries = await readdir(current, { withFileTypes: true });
+                for (const entry of entries) {
+                    // Skip node_modules, __tests__, dist directories
+                    if (entry.isDirectory()) {
+                        if (['node_modules', '__tests__', 'dist', '.git'].includes(entry.name)) {
+                            continue;
+                        }
+                        // Recurse into subdirectories
+                        await walk(join(current, entry.name));
+                    }
+                    else if (entry.isFile() && entry.name.endsWith('.ts')) {
+                        result.push(join(current, entry.name));
+                    }
+                }
+            }
+            catch {
+                // Directory doesn't exist or is unreadable, return empty
+            }
+        }
+        await walk(dir);
+        return result;
+    }
+    async function singleTs(filePath) {
+        try {
+            await stat(filePath);
+            return filePath;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const [domain, apis, webhooks, subscribers, actions, schedules, jobs, integrations, publishes] = await Promise.all([
+        singleTs(join(domainRoot, 'domain.config.ts')),
+        tsFiles(join(domainRoot, 'api')),
+        tsFiles(join(domainRoot, 'webhooks')),
+        tsFiles(join(domainRoot, 'subscribers')),
+        tsFiles(join(domainRoot, 'actions')),
+        tsFiles(join(domainRoot, 'schedules')),
+        tsFiles(join(domainRoot, 'jobs')),
+        tsFiles(join(domainRoot, 'integrations')),
+        singleTs(join(domainRoot, 'publishes', 'events.ts')),
+    ]);
+    return { domain, apis, webhooks, subscribers, actions, schedules, jobs, integrations, publishes };
+}