@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/src/adapters/kyselyCrud.ts

@@ -1,709 +0,0 @@
-import {
-  DatabasePluginInputError,
-  type BundleEventRow,
-  type BundlePatchRow,
-  type ChannelRow,
-  type ApiKeyRow,
-  type InsightsInstallationRow,
-  type InsightsRecordInput,
-  type ReleaseCatalogRow,
-} from "@hot-updater/plugin-core";
-import type {
-  DatabasePluginImplementation,
-  DatabaseWhere,
-  TransactionDatabasePluginImplementation,
-} from "@hot-updater/plugin-core/internal";
-import { sql, type QueryExecutorProvider, type RawBuilder } from "kysely";
-
-import type { ORMSQLProvider, RelationMode } from "../db/types";
-import {
-  isChannelDeleteReferencedError,
-  translateChannelDeleteError,
-} from "./databaseConstraintErrors";
-import {
-  fromStoredBundleRow,
-  fromStoredReleaseCatalogRow,
-  fromStoredReleaseRow,
-  type StoredBundleRow,
-  type StoredReleaseRow,
-  toStoredBundleRow,
-  toStoredBundleUpdate,
-  toStoredReleaseRow,
-  toStoredReleaseUpdate,
-} from "./databasePluginUtils";
-import { buildKyselyWhere } from "./kyselyQuery";
-
-class KyselyAdapterInvariantError extends Error {
-  readonly name = "KyselyAdapterInvariantError";
-
-  constructor(readonly reason: string) {
-    super(`Kysely plugin invariant failed: ${reason}`);
-  }
-}
-
-const empty = sql``;
-
-const lockClause = (
-  provider: Exclude<ORMSQLProvider, "mssql">,
-  relationMode: RelationMode,
-): RawBuilder<unknown> =>
-  relationMode === "fumadb" && provider !== "sqlite" ? sql` for update` : empty;
-
-const whereClause = (
-  where: RawBuilder<boolean> | undefined,
-): RawBuilder<unknown> => (where === undefined ? empty : sql` where ${where}`);
-
-const orderClause = (
-  input:
-    | {
-        readonly model?: string;
-        readonly orderBy?: readonly {
-          readonly direction: "asc" | "desc";
-          readonly field: string;
-          readonly nulls?: "first" | "last";
-        }[];
-      }
-    | undefined,
-): RawBuilder<unknown> => {
-  const clauses = input?.orderBy;
-  if (clauses === undefined || clauses.length === 0) return empty;
-  return sql` order by ${sql.join(
-    clauses.map((clause) => {
-      const field = sql.ref(clause.field);
-      if (
-        input?.model === "bundle_events" ||
-        input?.model === "bundle_installations"
-      ) {
-        return clause.direction === "asc"
-          ? sql`${field} asc`
-          : sql`${field} desc`;
-      }
-      const nulls =
-        clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
-      const nullOrder =
-        nulls === "first"
-          ? sql`${field} is null desc`
-          : sql`${field} is null asc`;
-      const valueOrder =
-        clause.direction === "asc" ? sql`${field} asc` : sql`${field} desc`;
-      return sql`${nullOrder}, ${valueOrder}`;
-    }),
-    sql`, `,
-  )}`;
-};
-
-const insertRow = async (
-  executor: QueryExecutorProvider,
-  table: string,
-  row: object,
-  provider: Exclude<ORMSQLProvider, "mssql">,
-  onConflict: "ignore" | undefined = undefined,
-): Promise<boolean> => {
-  const entries = Object.entries(row);
-  const columns = sql.join(entries.map(([field]) => sql.ref(field)));
-  const values = sql.join(entries.map(([, value]) => value));
-  const result =
-    onConflict === undefined
-      ? await sql`insert into ${sql.table(table)} (${columns}) values (${values})`.execute(
-          executor,
-        )
-      : provider === "mysql"
-        ? await sql`insert ignore into ${sql.table(table)} (${columns}) values (${values})`.execute(
-            executor,
-          )
-        : provider === "sqlite"
-          ? await sql`insert or ignore into ${sql.table(table)} (${columns}) values (${values})`.execute(
-              executor,
-            )
-          : await sql`insert into ${sql.table(table)} (${columns}) values (${values}) on conflict do nothing`.execute(
-              executor,
-            );
-  return Number(result.numAffectedRows ?? 0) > 0;
-};
-
-export const recordKyselyInsights = async (
-  executor: QueryExecutorProvider,
-  provider: Exclude<ORMSQLProvider, "mssql">,
-  { event, installation }: InsightsRecordInput,
-): Promise<void> => {
-  const insert = (table: string, row: object) => {
-    const entries = Object.entries(row);
-    return sql`insert into ${sql.table(table)} (${sql.join(entries.map(([field]) => sql.ref(field)))}) values (${sql.join(entries.map(([, value]) => value))})`;
-  };
-  if (provider === "mysql") {
-    const existing = await sql<{
-      id: string;
-    }>`select id from bundle_events where id = ${event.id} for update`.execute(
-      executor,
-    );
-    if (existing.rows.length > 0) return;
-    await insert("bundle_events", event).execute(executor);
-    await sql`${insert("bundle_installations", installation)} on duplicate key update install_id = ${installation.install_id}`.execute(
-      executor,
-    );
-  } else {
-    const result =
-      await sql`${insert("bundle_events", event)} on conflict (id) do nothing returning id`.execute(
-        executor,
-      );
-    if (result.rows.length === 0) return;
-    await sql`${insert("bundle_installations", installation)} on conflict (install_id) do nothing`.execute(
-      executor,
-    );
-  }
-  const assignments = Object.entries(installation).map(
-    ([field, value]) => sql`${sql.ref(field)} = ${value}`,
-  );
-  await sql`update ${sql.table("bundle_installations")} set ${sql.join(assignments)}
-    where ${sql.ref("install_id")} = ${installation.install_id}
-    and (${sql.ref("received_at_ms")} < ${installation.received_at_ms}
-      or (${sql.ref("received_at_ms")} = ${installation.received_at_ms}
-        and ${sql.ref("id")} < ${installation.id}))`.execute(executor);
-};
-
-const updateBundle = async (
-  executor: QueryExecutorProvider,
-  id: string,
-  update: object,
-): Promise<void> => {
-  const assignments = Object.entries(update)
-    .filter(([, value]) => value !== undefined)
-    .map(([field, value]) => sql`${sql.ref(field)} = ${value}`);
-  if (assignments.length === 0) return;
-  await sql`update ${sql.table("bundles")} set ${sql.join(
-    assignments,
-  )} where ${sql.ref("id")} = ${id}`.execute(executor);
-};
-
-const updateApiKey = async (
-  executor: QueryExecutorProvider,
-  id: string,
-  revokedAtMs: number | null,
-): Promise<void> => {
-  await sql`update ${sql.table("api_keys")} set ${sql.ref(
-    "revoked_at_ms",
-  )} = ${revokedAtMs} where ${sql.ref("id")} = ${id}`.execute(executor);
-};
-
-const updateRow = async (
-  executor: QueryExecutorProvider,
-  table: string,
-  keyField: string,
-  key: string,
-  update: object,
-): Promise<void> => {
-  const assignments = Object.entries(update)
-    .filter(([, value]) => value !== undefined)
-    .map(([field, value]) => sql`${sql.ref(field)} = ${value}`);
-  if (assignments.length === 0) return;
-  await sql`update ${sql.table(table)} set ${sql.join(
-    assignments,
-  )} where ${sql.ref(keyField)} = ${key}`.execute(executor);
-};
-
-const assertBundleReferences = async (
-  executor: QueryExecutorProvider,
-  provider: Exclude<ORMSQLProvider, "mssql">,
-  relationMode: RelationMode,
-  bundleId: string,
-  baseBundleId: string,
-): Promise<void> => {
-  const ids = [...new Set([bundleId, baseBundleId])].sort((left, right) =>
-    left.localeCompare(right),
-  );
-  const result = await sql<{ readonly id: string }>`select ${sql.ref(
-    "id",
-  )} from ${sql.table("bundles")} where ${sql.ref("id")} in (${sql.join(
-    ids,
-  )}) order by ${sql.ref("id")}${lockClause(provider, relationMode)}`.execute(
-    executor,
-  );
-  const storedIds = new Set(result.rows.map(({ id }) => id));
-  if (!storedIds.has(bundleId)) {
-    throw new KyselyAdapterInvariantError(
-      "bundle_patches.bundle_id.foreign-key",
-    );
-  }
-  if (!storedIds.has(baseBundleId)) {
-    throw new KyselyAdapterInvariantError(
-      "bundle_patches.base_bundle_id.foreign-key",
-    );
-  }
-};
-
-export const findKyselyBundles = async (
-  executor: QueryExecutorProvider,
-  provider: Exclude<ORMSQLProvider, "mssql">,
-  where: readonly DatabaseWhere<"bundles">[],
-): Promise<StoredBundleRow[]> => {
-  const result = await sql<StoredBundleRow>`select * from ${sql.table(
-    "bundles",
-  )}${whereClause(buildKyselyWhere(provider, where))} order by ${sql.ref(
-    "id",
-  )} desc`.execute(executor);
-  return [...result.rows];
-};
-
-export const findKyselyPatches = async (
-  executor: QueryExecutorProvider,
-  bundleIds: readonly string[],
-): Promise<BundlePatchRow[]> => {
-  if (bundleIds.length === 0) return [];
-  const result = await sql<BundlePatchRow>`select * from ${sql.table(
-    "bundle_patches",
-  )} where ${sql.ref("bundle_id")} in (${sql.join(
-    bundleIds,
-  )}) order by ${sql.ref("order_index")} asc`.execute(executor);
-  return [...result.rows];
-};
-
-const countRows = async (
-  executor: QueryExecutorProvider,
-  table: string,
-  where: RawBuilder<boolean> | undefined,
-): Promise<number> => {
-  const result = await sql<{
-    readonly total: bigint | number | string;
-  }>`select count(${sql.ref(
-    "id",
-  )}) as ${sql.ref("total")} from ${sql.table(table)}${whereClause(where)}`.execute(
-    executor,
-  );
-  return Number(result.rows[0]?.total ?? 0);
-};
-
-export const createKyselyCrud = (
-  executor: QueryExecutorProvider,
-  provider: Exclude<ORMSQLProvider, "mssql">,
-  relationMode: RelationMode = "foreign-keys",
-): TransactionDatabasePluginImplementation &
-  Pick<DatabasePluginImplementation, "deleteChannel" | "insertChannel"> => ({
-  async deleteChannel({ id }) {
-    const existing = await sql<ChannelRow>`select ${sql.ref("id")}, ${sql.ref(
-      "name",
-    )} from ${sql.table("channels")} where ${sql.ref(
-      "id",
-    )} = ${id} limit 1${lockClause(provider, relationMode)}`.execute(executor);
-    if (existing.rows[0] === undefined) {
-      return { deleted: false, reason: "not_found" };
-    }
-    const referencedReleases = await countRows(
-      executor,
-      "releases",
-      sql<boolean>`${sql.ref("channel_id")} = ${id}`,
-    );
-    if (referencedReleases > 0) {
-      return { deleted: false, reason: "not_empty" };
-    }
-    try {
-      await sql`delete from ${sql.table("channels")} where ${sql.ref(
-        "id",
-      )} = ${id}`.execute(executor);
-    } catch (error) {
-      if (isChannelDeleteReferencedError(error)) {
-        return { deleted: false, reason: "not_empty" };
-      }
-      throw error;
-    }
-    return { deleted: true };
-  },
-  async insertChannel(input) {
-    const inserted = await insertRow(
-      executor,
-      "channels",
-      input.row,
-      provider,
-      "ignore",
-    );
-    const result = await sql<ChannelRow>`select ${sql.ref("id")}, ${sql.ref(
-      "name",
-    )} from ${sql.table("channels")} where ${sql.ref("name")} = ${
-      input.row.name
-    } limit 1`.execute(executor);
-    const row = result.rows[0];
-    if (row === undefined) {
-      throw new KyselyAdapterInvariantError("channels.insert.return-existing");
-    }
-    return { row, inserted };
-  },
-  async create(input) {
-    switch (input.model) {
-      case "bundles":
-        await insertRow(
-          executor,
-          "bundles",
-          toStoredBundleRow(input.data, provider),
-          provider,
-        );
-        return input.data;
-      case "bundle_patches":
-        await assertBundleReferences(
-          executor,
-          provider,
-          relationMode,
-          input.data.bundle_id,
-          input.data.base_bundle_id,
-        );
-        await insertRow(executor, "bundle_patches", input.data, provider);
-        return input.data;
-      case "bundle_events":
-        await insertRow(executor, "bundle_events", input.data, provider);
-        return input.data;
-      case "bundle_installations":
-        await insertRow(
-          executor,
-          "bundle_installations",
-          input.data,
-          provider,
-          input.onConflict,
-        );
-        return input.data;
-      case "releases":
-        await insertRow(
-          executor,
-          "releases",
-          toStoredReleaseRow(input.data, provider),
-          provider,
-        );
-        return input.data;
-      case "release_catalogs":
-        await insertRow(executor, "release_catalogs", input.data, provider);
-        return input.data;
-      case "api_keys":
-        await insertRow(
-          executor,
-          "api_keys",
-          input.data,
-          provider,
-          input.onConflict,
-        );
-        return input.data;
-      case "channels":
-        await insertRow(
-          executor,
-          "channels",
-          input.data,
-          provider,
-          input.onConflict,
-        );
-        return input.data;
-    }
-  },
-  async update(input) {
-    if (input.model === "bundle_installations") {
-      const installId = input.where.find(
-        (item) =>
-          item.field === "install_id" &&
-          (item.operator === undefined || item.operator === "eq") &&
-          typeof item.value === "string",
-      )?.value;
-      if (typeof installId !== "string") {
-        throw new KyselyAdapterInvariantError(
-          "bundle_installations.update.selector",
-        );
-      }
-      const assignments = Object.entries(input.update)
-        .filter(([, value]) => value !== undefined)
-        .map(([field, value]) => sql`${sql.ref(field)} = ${value}`);
-      const where = buildKyselyWhere(provider, input.where);
-      let updated = false;
-      if (assignments.length > 0 && where !== undefined) {
-        const result = await sql`update ${sql.table(
-          "bundle_installations",
-        )} set ${sql.join(assignments)} where ${where}`.execute(executor);
-        updated = Number(result.numAffectedRows ?? 0) > 0;
-      }
-      if (!updated) return null;
-      const result =
-        await sql<InsightsInstallationRow>`select * from ${sql.table(
-          "bundle_installations",
-        )} where ${sql.ref("install_id")} = ${installId} limit 1`.execute(
-          executor,
-        );
-      return result.rows[0] ?? null;
-    }
-    const selector = input.where[0];
-    if (selector === undefined || typeof selector.value !== "string") {
-      throw new KyselyAdapterInvariantError(`${input.model}.update.selector`);
-    }
-    if (input.model === "api_keys") {
-      await updateApiKey(executor, selector.value, input.update.revoked_at_ms);
-      const result = await sql<ApiKeyRow>`select * from ${sql.table(
-        "api_keys",
-      )} where ${sql.ref("id")} = ${selector.value} limit 1`.execute(executor);
-      return result.rows[0] ?? null;
-    }
-    if (input.model === "releases") {
-      await updateRow(
-        executor,
-        "releases",
-        "id",
-        selector.value,
-        toStoredReleaseUpdate(input.update, provider),
-      );
-      const result = await sql<StoredReleaseRow>`select * from ${sql.table(
-        "releases",
-      )} where ${sql.ref("id")} = ${selector.value} limit 1`.execute(executor);
-      const row = result.rows[0];
-      return row === undefined ? null : fromStoredReleaseRow(row);
-    }
-    if (input.model === "release_catalogs") {
-      await updateRow(
-        executor,
-        "release_catalogs",
-        "scope_key",
-        selector.value,
-        input.update,
-      );
-      const result = await sql<ReleaseCatalogRow>`select * from ${sql.table(
-        "release_catalogs",
-      )} where ${sql.ref("scope_key")} = ${selector.value} limit 1`.execute(
-        executor,
-      );
-      const row = result.rows[0];
-      return row === undefined ? null : fromStoredReleaseCatalogRow(row);
-    }
-    await updateBundle(
-      executor,
-      selector.value,
-      toStoredBundleUpdate(input.update, provider),
-    );
-    const result = await sql<StoredBundleRow>`select * from ${sql.table(
-      "bundles",
-    )} where ${sql.ref("id")} = ${selector.value} limit 1`.execute(executor);
-    const stored = result.rows[0];
-    if (stored === undefined) return null;
-    return fromStoredBundleRow(stored);
-  },
-  async delete(input) {
-    switch (input.model) {
-      case "bundles": {
-        const where = buildKyselyWhere(provider, input.where);
-        if (where === undefined) {
-          throw new KyselyAdapterInvariantError("bundles.delete.where");
-        }
-        if (relationMode === "fumadb") {
-          const matchingBundles = await sql<{
-            readonly id: string;
-          }>`select ${sql.ref(
-            "id",
-          )} from ${sql.table("bundles")} where ${where} order by ${sql.ref(
-            "id",
-          )}${lockClause(provider, relationMode)}`.execute(executor);
-          const bundleIds = matchingBundles.rows.map(({ id }) => id);
-          if (bundleIds.length === 0) return;
-          await sql`delete from ${sql.table("bundle_patches")} where ${sql.ref(
-            "bundle_id",
-          )} in (${sql.join(bundleIds)}) or ${sql.ref("base_bundle_id")} in (${sql.join(
-            bundleIds,
-          )})`.execute(executor);
-        }
-        await sql`delete from ${sql.table("bundles")} where ${where}`.execute(
-          executor,
-        );
-        return;
-      }
-      case "bundle_patches": {
-        const where = buildKyselyWhere(provider, input.where);
-        if (where === undefined) {
-          throw new KyselyAdapterInvariantError("bundle_patches.delete.where");
-        }
-        await sql`delete from ${sql.table("bundle_patches")} where ${where}`.execute(
-          executor,
-        );
-        return;
-      }
-      case "releases": {
-        const where = buildKyselyWhere(provider, input.where);
-        if (where === undefined) {
-          throw new KyselyAdapterInvariantError("releases.delete.where");
-        }
-        await sql`delete from ${sql.table("releases")} where ${where}`.execute(
-          executor,
-        );
-        return;
-      }
-      case "channels": {
-        const where = buildKyselyWhere(provider, input.where);
-        if (where === undefined) {
-          throw new KyselyAdapterInvariantError("channels.delete.where");
-        }
-        try {
-          await sql`delete from ${sql.table(
-            "channels",
-          )} where ${where}`.execute(executor);
-        } catch (error) {
-          translateChannelDeleteError(error);
-        }
-        return;
-      }
-    }
-  },
-  async count(input) {
-    if (input.distinct !== undefined) {
-      throw new DatabasePluginInputError("invalid-operation");
-    }
-    switch (input.model) {
-      case "bundle_events":
-        return countRows(
-          executor,
-          "bundle_events",
-          buildKyselyWhere(provider, input.where),
-        );
-      case "bundles":
-        return countRows(
-          executor,
-          "bundles",
-          buildKyselyWhere(provider, input.where),
-        );
-      case "bundle_patches":
-        return countRows(
-          executor,
-          "bundle_patches",
-          buildKyselyWhere(provider, input.where),
-        );
-      case "releases":
-        return countRows(
-          executor,
-          "releases",
-          buildKyselyWhere(provider, input.where),
-        );
-      case "bundle_installations":
-        return countRows(
-          executor,
-          "bundle_installations",
-          buildKyselyWhere(provider, input.where),
-        );
-    }
-  },
-  async findOne(input) {
-    switch (input.model) {
-      case "bundles": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result = await sql<StoredBundleRow>`select * from ${sql.table(
-          "bundles",
-        )}${where} limit 1`.execute(executor);
-        const row = result.rows[0];
-        return row === undefined ? null : fromStoredBundleRow(row);
-      }
-      case "bundle_patches": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result = await sql<BundlePatchRow>`select * from ${sql.table(
-          "bundle_patches",
-        )}${where} limit 1`.execute(executor);
-        return result.rows[0] ?? null;
-      }
-      case "api_keys": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result = await sql<ApiKeyRow>`select * from ${sql.table(
-          "api_keys",
-        )}${where} limit 1`.execute(executor);
-        return result.rows[0] ?? null;
-      }
-      case "channels": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result = await sql<ChannelRow>`select * from ${sql.table(
-          "channels",
-        )}${where} limit 1`.execute(executor);
-        return result.rows[0] ?? null;
-      }
-      case "releases": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result = await sql<StoredReleaseRow>`select * from ${sql.table(
-          "releases",
-        )}${where} limit 1`.execute(executor);
-        const row = result.rows[0];
-        return row === undefined ? null : fromStoredReleaseRow(row);
-      }
-      case "release_catalogs": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result = await sql<ReleaseCatalogRow>`select * from ${sql.table(
-          "release_catalogs",
-        )}${where} limit 1`.execute(executor);
-        const row = result.rows[0];
-        return row === undefined ? null : fromStoredReleaseCatalogRow(row);
-      }
-      case "bundle_installations": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const result =
-          await sql<InsightsInstallationRow>`select * from ${sql.table(
-            "bundle_installations",
-          )}${where} limit 1`.execute(executor);
-        return result.rows[0] ?? null;
-      }
-    }
-  },
-  async findMany(input) {
-    if (input.distinctOn !== undefined) {
-      throw new DatabasePluginInputError("invalid-operation");
-    }
-    const pagination = sql` limit ${input.limit} offset ${input.offset}`;
-    switch (input.model) {
-      case "bundles": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<StoredBundleRow>`select * from ${sql.table(
-          "bundles",
-        )}${where}${order}${pagination}`.execute(executor);
-        return result.rows.map(fromStoredBundleRow);
-      }
-      case "bundle_patches": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<BundlePatchRow>`select * from ${sql.table(
-          "bundle_patches",
-        )}${where}${order}${pagination}`.execute(executor);
-        return [...result.rows];
-      }
-      case "bundle_events": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<BundleEventRow>`select * from ${sql.table(
-          "bundle_events",
-        )}${where}${order}${pagination}`.execute(executor);
-        return [...result.rows];
-      }
-      case "bundle_installations": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result =
-          await sql<InsightsInstallationRow>`select * from ${sql.table(
-            "bundle_installations",
-          )}${where}${order}${pagination}`.execute(executor);
-        return [...result.rows];
-      }
-      case "api_keys": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<ApiKeyRow>`select * from ${sql.table(
-          "api_keys",
-        )}${where}${order}${pagination}`.execute(executor);
-        return [...result.rows];
-      }
-      case "channels": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<ChannelRow>`select * from ${sql.table(
-          "channels",
-        )}${where}${order}${pagination}`.execute(executor);
-        return [...result.rows];
-      }
-      case "releases": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<StoredReleaseRow>`select * from ${sql.table(
-          "releases",
-        )}${where}${order}${pagination}`.execute(executor);
-        return result.rows.map(fromStoredReleaseRow);
-      }
-      case "release_catalogs": {
-        const where = whereClause(buildKyselyWhere(provider, input.where));
-        const order = orderClause(input);
-        const result = await sql<ReleaseCatalogRow>`select * from ${sql.table(
-          "release_catalogs",
-        )}${where}${order}${pagination}`.execute(executor);
-        return result.rows.map(fromStoredReleaseCatalogRow);
-      }
-    }
-  },
-});