handoff-app 1.2.2-6 → 2.0.0-0

package/src/app/lib/registry-api/allowlist.ts

@@ -0,0 +1,163 @@
+import type { RegistryReviewMetadata } from '@handoff/registry/db/schema';
+import { isSafePathSegment, isSafeRelativePath } from '@handoff/registry/path';
+import { isPlainObject } from './validation';
+
+/**
+ * Metadata allowlist for registry create/update.
+ *
+ * Normal metadata writes accept only review/catalog fields. Everything else — renderer, entries,
+ * previews, properties/docgen, source/artifact content, build metadata, declaration files, etc. —
+ * is render/build-defining and may only change through a fresh publish (transfer PUT).
+ * Any non-allowlisted field is rejected with `400 bad_request` and the offending field names, so a
+ * note edit can never silently alter how an entity renders.
+ */
+export type ManagedEntityKind = 'component' | 'pattern' | 'page';
+
+/**
+ * Top-level allowlisted fields per entity kind. Components additionally allow `categories`; pages
+ * have no promoted `tags` column, so their catalog fields stop at title/description/group.
+ */
+const TOP_LEVEL_FIELDS: Record<ManagedEntityKind, readonly string[]> = {
+  component: ['title', 'description', 'group', 'tags', 'categories'],
+  pattern: ['title', 'description', 'group', 'tags'],
+  page: ['title', 'description', 'group'],
+};
+
+/** Allowlisted nested review-metadata keys. */
+const METADATA_FIELDS: readonly (keyof RegistryReviewMetadata)[] = ['reviewStatus', 'notes', 'owner'];
+
+/** String-array fields (validated element-wise). */
+const ARRAY_FIELDS = new Set(['tags', 'categories']);
+/** Plain-string fields. */
+const STRING_FIELDS = new Set(['title', 'description', 'group']);
+
+/** Validated, allowlist-filtered metadata write. */
+export interface ValidatedMetadataWrite {
+  /** Stable id, present only for create (POST) when `allowId` is set. */
+  id?: string;
+  /** Allowlisted top-level field values present in the request body. */
+  fields: Record<string, unknown>;
+  /** Allowlisted review-metadata present in the request body, or `undefined` when none supplied. */
+  metadata?: RegistryReviewMetadata;
+}
+
+/**
+ * Result of {@link validateMetadataWrite}. A flat shape (rather than a discriminated union) because
+ * the app compiles with `strictNullChecks` off, where union narrowing is unreliable — `ok` is the
+ * single source of truth, with `value` set on success and `rejectedFields`/`message` on failure.
+ */
+export interface MetadataValidation {
+  ok: boolean;
+  value?: ValidatedMetadataWrite;
+  rejectedFields?: string[];
+  message?: string;
+}
+
+const isStringArray = (value: unknown): value is string[] => Array.isArray(value) && value.every((item) => typeof item === 'string');
+
+export interface ValidateMetadataOptions {
+  /** Allow (and require) an `id` field — used by create (POST). */
+  allowId?: boolean;
+}
+
+/**
+ * Validate and allowlist-filter a metadata create/update body for the given entity kind. Returns
+ * the filtered write on success, or the list of rejected field names (render/build-defining keys,
+ * unknown keys, or type-invalid values) on failure.
+ */
+export const validateMetadataWrite = (
+  body: unknown,
+  kind: ManagedEntityKind,
+  options: ValidateMetadataOptions = {}
+): MetadataValidation => {
+  if (!isPlainObject(body)) {
+    return { ok: false, rejectedFields: [], message: 'Request body must be a JSON object.' };
+  }
+
+  const allowed = new Set(TOP_LEVEL_FIELDS[kind]);
+  const rejectedFields: string[] = [];
+  const fields: Record<string, unknown> = {};
+  let metadata: RegistryReviewMetadata | undefined;
+  let id: string | undefined;
+
+  for (const [key, value] of Object.entries(body)) {
+    if (key === 'id') {
+      if (!options.allowId) {
+        // Identity is immutable; an `id` in an update body is render/build-irrelevant but not allowed.
+        rejectedFields.push('id');
+        continue;
+      }
+      const candidate = typeof value === 'string' ? value.trim() : '';
+      const validId = kind === 'page' ? isSafeRelativePath(candidate) : isSafePathSegment(candidate);
+      if (!validId) {
+        rejectedFields.push('id');
+        continue;
+      }
+      id = candidate;
+      continue;
+    }
+
+    if (key === 'metadata') {
+      if (!isPlainObject(value)) {
+        rejectedFields.push('metadata');
+        continue;
+      }
+      const reviewMetadata: RegistryReviewMetadata = {};
+      for (const [metaKey, metaValue] of Object.entries(value)) {
+        if (!METADATA_FIELDS.includes(metaKey as keyof RegistryReviewMetadata)) {
+          rejectedFields.push(`metadata.${metaKey}`);
+          continue;
+        }
+        if (typeof metaValue !== 'string') {
+          rejectedFields.push(`metadata.${metaKey}`);
+          continue;
+        }
+        reviewMetadata[metaKey as keyof RegistryReviewMetadata] = metaValue;
+      }
+      metadata = reviewMetadata;
+      continue;
+    }
+
+    if (!allowed.has(key)) {
+      rejectedFields.push(key);
+      continue;
+    }
+
+    if (STRING_FIELDS.has(key) && typeof value !== 'string') {
+      rejectedFields.push(key);
+      continue;
+    }
+    if (ARRAY_FIELDS.has(key) && !isStringArray(value)) {
+      rejectedFields.push(key);
+      continue;
+    }
+    fields[key] = value;
+  }
+
+  if (options.allowId && !id) {
+    rejectedFields.push('id');
+  }
+
+  if (rejectedFields.length > 0) {
+    return {
+      ok: false,
+      rejectedFields,
+      message:
+        'Only allowlisted review/catalog fields may be written here. Render/build-defining fields, ' +
+        'source, and artifacts can only change through publish.',
+    };
+  }
+
+  return { ok: true, value: { id, fields, metadata } };
+};
+
+/** Merge a validated review-metadata write over the existing stored metadata. */
+export const mergeReviewMetadata = (
+  existing: RegistryReviewMetadata | null | undefined,
+  update: RegistryReviewMetadata | undefined
+): RegistryReviewMetadata | null => {
+  if (!update) {
+    return existing ?? null;
+  }
+  return { ...(existing ?? {}), ...update };
+};

package/src/app/lib/registry-api/asset-transfer.ts

@@ -0,0 +1,363 @@
+import crypto from 'crypto';
+import type { NextApiRequest, NextApiResponse } from 'next';
+import { eq, inArray } from 'drizzle-orm';
+import type { RegistryDatabase } from '@handoff/registry/db/client';
+import { assetBlobs, assetCollections, assets } from '@handoff/registry/db/schema';
+import { isAssetCollection, type AssetCollection } from '@handoff/registry/assets/sets';
+import type { AssetCollectionTransferPackage, AssetManifestEntry } from '@handoff/registry/assets/transfer';
+import { singleQueryValue } from '../api/query';
+import { getActiveAssetStorage, getActiveAssetStorageAdapter, getAssetStorageAdapter } from '../asset-storage';
+import { sendRegistryError } from './errors';
+import { buildMeta } from './meta';
+import { handleRegistryRoute, sendRegistryData } from './handler';
+import {
+  asString,
+  invalidPackage as invalid,
+  isPlainObject,
+  isSha256Hash,
+  normalizeSafeRelativePath,
+  type PackageValidation,
+  validateTransferBuild,
+} from './validation';
+
+/**
+ * Asset transfer ingestion + serving for the registry.
+ *
+ * - `GET  /api/registry/transfer/assets` lists collection summaries (collection + source hash).
+ * - `GET  /api/registry/transfer/assets/:collection` is checkout: the collection manifest metadata.
+ * - `PUT  /api/registry/transfer/assets/:collection` is publish ingestion: validates the manifest,
+ *   asserts every referenced blob already exists (so a manifest never references missing content),
+ *   then atomically upserts the `asset_collections` row and replaces its `assets` rows in one
+ *   transaction. An unchanged collection (matching `sourceHash`) is a no-op.
+ * - `POST /api/registry/transfer/assets/blobs/have` returns which content hashes are missing.
+ * - `PUT  /api/registry/transfer/assets/blobs/:hash` stores one content-addressed blob (binary body)
+ *   through the active storage provider (inline `bytea` by default). Idempotent by hash.
+ * - `GET  /api/registry/transfer/assets/blobs/:hash` returns/redirects to one blob's bytes.
+ *
+ * Runs behind {@link handleRegistryRoute}: runtime-mode, method, bearer-token (on mutations), and
+ * database guards apply before any of this executes.
+ */
+
+/** Validate an asset collection publish package (manifest metadata only; bodies travel as blobs). */
+const validateAssetPackage = (body: unknown, collection: string): PackageValidation<AssetCollectionTransferPackage> => {
+  if (!isPlainObject(body)) {
+    return invalid('Request body must be a JSON object.');
+  }
+  if (!isAssetCollection(collection)) {
+    return invalid(`Unknown asset collection "${collection}".`, { rejectedFields: ['collection'] });
+  }
+  const bodyCollection = asString(body.collection);
+  if (bodyCollection !== undefined && bodyCollection !== collection) {
+    return invalid(`Package collection "${bodyCollection}" does not match the publish target "${collection}".`, {
+      rejectedFields: ['collection'],
+    });
+  }
+
+  const rawAssets = body.assets ?? [];
+  if (!Array.isArray(rawAssets)) {
+    return invalid('`assets` must be an array.', { rejectedFields: ['assets'] });
+  }
+  const manifest: AssetManifestEntry[] = [];
+  const seenPaths = new Set<string>();
+  for (let i = 0; i < rawAssets.length; i += 1) {
+    const raw = rawAssets[i];
+    const field = (name: string) => `assets[${i}].${name}`;
+    if (!isPlainObject(raw)) {
+      return invalid('Each asset must be an object.', { rejectedFields: [`assets[${i}]`] });
+    }
+    const assetPath = normalizeSafeRelativePath(raw.path);
+    if (!assetPath) {
+      return invalid('Asset path must be a registry-safe relative path.', { rejectedFields: [field('path')] });
+    }
+    if (seenPaths.has(assetPath)) {
+      return invalid(`Duplicate asset path "${assetPath}" in manifest.`, { rejectedFields: [field('path')] });
+    }
+    seenPaths.add(assetPath);
+    const contentHash = asString(raw.contentHash);
+    if (!isSha256Hash(contentHash)) {
+      return invalid(`Asset "${assetPath}" is missing a valid SHA-256 contentHash.`, { rejectedFields: [field('contentHash')] });
+    }
+    manifest.push({
+      path: assetPath,
+      name: asString(raw.name) || assetPath,
+      contentType: asString(raw.contentType) || 'application/octet-stream',
+      size: typeof raw.size === 'number' ? raw.size : 0,
+      contentHash: contentHash.toLowerCase(),
+      metadata: isPlainObject(raw.metadata) ? (raw.metadata as Record<string, unknown>) : null,
+    });
+  }
+
+  const buildValidation = validateTransferBuild(body.build, {
+    requiredHashField: 'sourceHash',
+    currentMessage: 'A "current" asset build requires builtAt, builderVersion, and sourceHash.',
+  });
+  if (!buildValidation.ok) {
+    return invalid(buildValidation.message, buildValidation.details);
+  }
+  const build = buildValidation.value;
+
+  return {
+    ok: true,
+    value: {
+      collection: collection as AssetCollection,
+      assets: manifest,
+      build: {
+        status: build.status,
+        builtAt: build.builtAt,
+        builderVersion: build.builderVersion,
+        sourceHash: build.sourceHash,
+      },
+    },
+  };
+};
+
+/** The stored source hash for a collection, or `undefined` when it does not exist yet. */
+const storedSourceHash = async (db: RegistryDatabase, collection: string): Promise<string | null | undefined> => {
+  const rows = await db
+    .select({ sourceHash: assetCollections.sourceHash })
+    .from(assetCollections)
+    .where(eq(assetCollections.collection, collection as AssetCollection))
+    .limit(1);
+  return rows.length ? rows[0].sourceHash : undefined;
+};
+
+/** Atomically upsert the collection row and replace its manifest rows in one transaction. */
+const ingestAssetCollection = async (db: RegistryDatabase, pkg: AssetCollectionTransferPackage): Promise<void> => {
+  const collectionValues = {
+    sourceHash: pkg.build.sourceHash ?? null,
+    status: pkg.build.status,
+    builtAt: pkg.build.builtAt ? new Date(pkg.build.builtAt) : null,
+    builderVersion: pkg.build.builderVersion ?? null,
+    updatedAt: new Date(),
+  };
+
+  await db.transaction(async (tx) => {
+    await tx
+      .insert(assetCollections)
+      .values({ collection: pkg.collection, metadata: null, ...collectionValues } as any)
+      .onConflictDoUpdate({ target: assetCollections.collection, set: collectionValues as any });
+
+    await tx.delete(assets).where(eq(assets.collection, pkg.collection));
+    for (const asset of pkg.assets) {
+      await tx.insert(assets).values({
+        collection: pkg.collection,
+        path: asset.path,
+        name: asset.name,
+        contentType: asset.contentType,
+        size: asset.size,
+        contentHash: asset.contentHash,
+        metadata: asset.metadata ?? null,
+        blobHash: asset.contentHash,
+      } as any);
+    }
+  });
+};
+
+/** Read the raw binary request body (blob upload routes disable the JSON body parser). */
+const readRawBody = (req: NextApiRequest): Promise<Buffer> =>
+  new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk: Buffer) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+
+/** `GET /api/registry/transfer/assets`: list collection summaries. */
+export const handleAssetSummaryRoute = (req: NextApiRequest, res: NextApiResponse): Promise<void> =>
+  handleRegistryRoute(req, res, ['GET'], async ({ db }) => {
+    const rows = await db
+      .select({ collection: assetCollections.collection, sourceHash: assetCollections.sourceHash, status: assetCollections.status })
+      .from(assetCollections);
+    sendRegistryData(res, 200, { collections: rows }, buildMeta());
+  });
+
+/** `GET|PUT /api/registry/transfer/assets/:collection`: checkout / publish one collection manifest. */
+export const handleAssetCollectionRoute = (req: NextApiRequest, res: NextApiResponse): Promise<void> =>
+  handleRegistryRoute(req, res, ['GET', 'PUT'], async ({ db, method }) => {
+    const collection = singleQueryValue(req.query.collection) ?? '';
+    if (!collection) {
+      sendRegistryError(res, 'not_found', 'Missing asset collection.');
+      return;
+    }
+
+    if (method === 'GET') {
+      const found = await db
+        .select({ collection: assetCollections.collection })
+        .from(assetCollections)
+        .where(eq(assetCollections.collection, collection as AssetCollection))
+        .limit(1);
+      if (!found.length) {
+        sendRegistryError(res, 'not_found', `No asset collection "${collection}" exists in the registry.`);
+        return;
+      }
+      const rows = await db
+        .select({
+          path: assets.path,
+          name: assets.name,
+          contentType: assets.contentType,
+          size: assets.size,
+          contentHash: assets.contentHash,
+          metadata: assets.metadata,
+        })
+        .from(assets)
+        .where(eq(assets.collection, collection as AssetCollection));
+      sendRegistryData(res, 200, { collection, assets: rows }, buildMeta());
+      return;
+    }
+
+    // PUT: publish ingestion.
+    const validation = validateAssetPackage(req.body, collection);
+    if (!validation.ok) {
+      sendRegistryError(res, 'bad_request', validation.message ?? 'Invalid asset collection package.', validation.details);
+      return;
+    }
+    const pkg = validation.value;
+
+    const existingHash = await storedSourceHash(db, collection);
+    if (existingHash && pkg.build.sourceHash && existingHash === pkg.build.sourceHash) {
+      sendRegistryData(res, 200, { collection, published: false, unchanged: true }, buildMeta());
+      return;
+    }
+
+    // Guard: never finalize a manifest that references a blob the registry does not have.
+    const referenced = Array.from(new Set(pkg.assets.map((asset) => asset.contentHash)));
+    if (referenced.length > 0) {
+      const present = await db.select({ hash: assetBlobs.hash }).from(assetBlobs).where(inArray(assetBlobs.hash, referenced));
+      const presentSet = new Set(present.map((row) => row.hash));
+      const missing = referenced.filter((hash) => !presentSet.has(hash));
+      if (missing.length > 0) {
+        sendRegistryError(
+          res,
+          'bad_request',
+          `Cannot finalize collection "${collection}": ${missing.length} referenced blob(s) were not uploaded.`,
+          {
+            rejectedFields: ['assets'],
+            missing,
+          }
+        );
+        return;
+      }
+    }
+
+    await ingestAssetCollection(db, pkg);
+    sendRegistryData(res, 200, { collection, published: true, assets: pkg.assets.length }, buildMeta());
+  });
+
+/** `POST /api/registry/transfer/assets/blobs/have`: return which of the given hashes are missing. */
+export const handleAssetBlobHaveRoute = (req: NextApiRequest, res: NextApiResponse): Promise<void> =>
+  handleRegistryRoute(req, res, ['POST'], async ({ db }) => {
+    const body = req.body;
+    const hashes = isPlainObject(body) && Array.isArray(body.hashes) ? body.hashes.filter((h): h is string => typeof h === 'string') : [];
+    if (hashes.length === 0) {
+      sendRegistryData(res, 200, { missing: [] }, buildMeta());
+      return;
+    }
+    const present = await db.select({ hash: assetBlobs.hash }).from(assetBlobs).where(inArray(assetBlobs.hash, hashes));
+    const presentSet = new Set(present.map((row) => row.hash));
+    sendRegistryData(res, 200, { missing: hashes.filter((hash) => !presentSet.has(hash)) }, buildMeta());
+  });
+
+/** `PUT|GET /api/registry/transfer/assets/blobs/:hash`: store / fetch one content-addressed blob. */
+export const handleAssetBlobRoute = (req: NextApiRequest, res: NextApiResponse): Promise<void> =>
+  handleRegistryRoute(req, res, ['GET', 'PUT'], async ({ db, method }) => {
+    const hash = (singleQueryValue(req.query.hash) ?? '').toLowerCase();
+    if (!isSha256Hash(hash)) {
+      sendRegistryError(res, 'bad_request', 'Blob hash must be a SHA-256 hex string.');
+      return;
+    }
+
+    if (method === 'PUT') {
+      const bytes = await readRawBody(req);
+      const actual = crypto.createHash('sha256').update(bytes).digest('hex');
+      if (actual !== hash) {
+        sendRegistryError(res, 'bad_request', `Uploaded content hash "${actual}" does not match the target "${hash}".`, {
+          rejectedFields: ['hash'],
+        });
+        return;
+      }
+      const existing = await db.select({ hash: assetBlobs.hash }).from(assetBlobs).where(eq(assetBlobs.hash, hash)).limit(1);
+      if (existing.length > 0) {
+        sendRegistryData(res, 200, { hash, stored: true }, buildMeta());
+        return;
+      }
+      const contentType =
+        (Array.isArray(req.headers['content-type']) ? req.headers['content-type'][0] : req.headers['content-type']) ||
+        'application/octet-stream';
+      const active = getActiveAssetStorage();
+
+      let storageProvider = active.provider;
+      let content: Buffer | null = null;
+      let storageRef: string | null = null;
+      if (active.provider === 'database') {
+        if (bytes.length > active.maxInlineBytes) {
+          sendRegistryError(
+            res,
+            'bad_request',
+            `Blob is ${bytes.length} bytes, above the database inline limit of ${active.maxInlineBytes}. Configure object storage (runtime.registry.assetStorage) for large assets.`
+          );
+          return;
+        }
+        content = bytes;
+      } else {
+        const adapter = await getActiveAssetStorageAdapter();
+        if (!adapter) {
+          sendRegistryError(res, 'unexpected_error', `No storage adapter is available for provider "${active.provider}".`);
+          return;
+        }
+        ({ storageRef } = await adapter.put({ hash, bytes, contentType, size: bytes.length }));
+        storageProvider = active.provider;
+      }
+
+      await db
+        .insert(assetBlobs)
+        .values({ hash, storageProvider, content, storageRef, contentType, size: bytes.length } as any)
+        .onConflictDoNothing({ target: assetBlobs.hash });
+      sendRegistryData(res, 200, { hash, stored: true }, buildMeta());
+      return;
+    }
+
+    // GET: resolve and serve the blob bytes (redirecting to object storage where possible).
+    const rows = await db
+      .select({
+        content: assetBlobs.content,
+        storageRef: assetBlobs.storageRef,
+        storageProvider: assetBlobs.storageProvider,
+        contentType: assetBlobs.contentType,
+      })
+      .from(assetBlobs)
+      .where(eq(assetBlobs.hash, hash))
+      .limit(1);
+    const blob = rows[0];
+    if (!blob) {
+      sendRegistryError(res, 'not_found', `No blob "${hash}" exists in the registry.`);
+      return;
+    }
+
+    res.setHeader('ETag', `"${hash}"`);
+    res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+    if (blob.content != null) {
+      res.setHeader('Content-Type', blob.contentType);
+      res.status(200).send(Buffer.from(blob.content));
+      return;
+    }
+    if (!blob.storageRef) {
+      sendRegistryError(res, 'not_found', `Blob "${hash}" has no resolvable content.`);
+      return;
+    }
+    const adapter = await getAssetStorageAdapter(blob.storageProvider);
+    if (!adapter) {
+      sendRegistryError(res, 'unexpected_error', `No storage adapter is available for provider "${blob.storageProvider}".`);
+      return;
+    }
+    const result = await adapter.get(blob.storageRef);
+    if (result.kind === 'redirect') {
+      res.redirect(302, result.url);
+      return;
+    }
+    res.setHeader('Content-Type', result.contentType || blob.contentType);
+    if (result.kind === 'bytes') {
+      res.status(200).send(result.bytes);
+      return;
+    }
+    result.stream.pipe(res);
+  });

package/src/app/lib/registry-api/auth.ts

@@ -0,0 +1,68 @@
+import type { NextApiRequest } from 'next';
+import { getServerRuntimeConfig } from '../docs-api/runtime-config';
+
+/**
+ * Bearer-token guard for registry management mutations.
+ *
+ * This is **proof-of-concept protection**, not production auth: a single static token, resolved
+ * from the configured env-var *name* at request time (never persisted in config). GET reads are
+ * unauthenticated; only mutations (POST/PUT/DELETE) call this guard.
+ *
+ * - Token env var unset/empty  → `token_not_configured` (503).
+ * - `Authorization: Bearer <token>` missing or not an exact match → `unauthorized` (401).
+ */
+/**
+ * Result of {@link authorizeMutation}. Flat (not a discriminated union) because the app compiles
+ * with `strictNullChecks` off — `ok` decides, with `code`/`message` set on failure.
+ */
+export interface MutationAuthResult {
+  ok: boolean;
+  code?: 'token_not_configured' | 'unauthorized';
+  message?: string;
+}
+
+/** Length-safe constant-time-ish string comparison to avoid trivial timing leaks. */
+const tokensMatch = (provided: string, expected: string): boolean => {
+  if (provided.length !== expected.length) {
+    return false;
+  }
+  let mismatch = 0;
+  for (let i = 0; i < expected.length; i += 1) {
+    mismatch |= provided.charCodeAt(i) ^ expected.charCodeAt(i);
+  }
+  return mismatch === 0;
+};
+
+/** Extract a bearer token from the `Authorization` header, or `''` when absent/malformed. */
+const bearerToken = (req: NextApiRequest): string => {
+  const header = req.headers.authorization;
+  if (typeof header !== 'string') {
+    return '';
+  }
+  const match = /^Bearer\s+(.+)$/i.exec(header.trim());
+  return match ? match[1].trim() : '';
+};
+
+/** Authorize a mutation request against the configured static bearer token. */
+export const authorizeMutation = (req: NextApiRequest): MutationAuthResult => {
+  const { registry } = getServerRuntimeConfig();
+  const expected = process.env[registry.apiTokenEnv]?.trim();
+  if (!expected) {
+    return {
+      ok: false,
+      code: 'token_not_configured',
+      message:
+        `Registry management mutations are disabled because the "${registry.apiTokenEnv}" environment ` +
+        `variable is not set. Set it to a bearer token to enable mutations.`,
+    };
+  }
+  const provided = bearerToken(req);
+  if (!provided || !tokensMatch(provided, expected)) {
+    return {
+      ok: false,
+      code: 'unauthorized',
+      message: 'A valid "Authorization: Bearer <token>" header is required for registry management mutations.',
+    };
+  }
+  return { ok: true };
+};