create-ailk 0.23.0 → 0.25.1

package/templates/database/__tests__/seed.test.ts

@@ -1,240 +0,0 @@
-/**
- * @file seed.test.ts
- *
- * DB-free unit test for `provisionDefaultWorkspace` (#3622 —
- * docs/specs/default-workspace-provision-spec.md AC-1 / AC-2).
- *
- * Prisma is injected as a lightweight jest-mock stub typed as
- * `DefaultWorkspacePrismaClient` — no live Postgres, mirroring the DB-free
- * convention in database/__tests__/user-cascade.test.ts and the
- * `createAuth({ prisma })` DI pattern in apps-paid/admin/__tests__.
- */
-
-import {
-  CONTACT_FORM_FLOW_SLUG,
-  contactFormFlowConfig,
-  JOB_APPLICATION_FLOW_SLUG,
-  jobApplicationFlowConfig,
-  NEWSLETTER_FLOW_SLUG,
-  newsletterFlowConfig,
-  REQUEST_QUOTE_FLOW_SLUG,
-  REQUEST_QUOTE_FLOW_TITLE,
-  requestQuoteFlowConfig,
-  STANDARD_MAGNET_COMPLETIONS,
-} from "@working-theory/validation";
-
-import {
-  DEFAULT_ORG_ID,
-  DEFAULT_ORG_SLUG,
-  DEFAULT_WORKSPACE_ID,
-  DEFAULT_WORKSPACE_SLUG,
-  provisionDefaultWorkspace,
-  type DefaultWorkspacePrismaClient,
-} from "../seed";
-
-function makeStubPrisma(workspaceCount: number) {
-  const organizationUpsert = jest.fn().mockResolvedValue({});
-  const workspaceUpsert = jest.fn().mockResolvedValue({});
-  const workspaceCountFn = jest.fn().mockResolvedValue(workspaceCount);
-  const flowDefinitionUpsert = jest.fn().mockResolvedValue({});
-
-  // Minimal Prisma delegate stub — only the three delegates
-  // provisionDefaultWorkspace touches. The full PrismaClient delegate method
-  // signatures are impractical to satisfy for a hand-built DB-free stub, so a
-  // double assertion through `unknown` is the sanctioned boundary here.
-  // eslint-disable-next-line no-restricted-syntax -- test stub: minimal Prisma delegate surface; full delegate types impractical for a DB-free unit stub
-  const prisma = {
-    organization: { upsert: organizationUpsert },
-    workspace: { count: workspaceCountFn, upsert: workspaceUpsert },
-    flowDefinition: { upsert: flowDefinitionUpsert },
-  } as unknown as DefaultWorkspacePrismaClient;
-
-  return {
-    prisma,
-    organizationUpsert,
-    workspaceUpsert,
-    workspaceCountFn,
-    flowDefinitionUpsert,
-  };
-}
-
-describe("provisionDefaultWorkspace (#3622)", () => {
-  it("AC-1: given workspace.count() === 0, upserts one default Organization + Workspace and returns { created: true }", async () => {
-    const { prisma, organizationUpsert, workspaceUpsert, workspaceCountFn } =
-      makeStubPrisma(0);
-
-    const result = await provisionDefaultWorkspace(prisma);
-
-    expect(result).toEqual({ created: true });
-    expect(workspaceCountFn).toHaveBeenCalledTimes(1);
-
-    expect(organizationUpsert).toHaveBeenCalledTimes(1);
-    expect(organizationUpsert).toHaveBeenCalledWith({
-      where: { slug: DEFAULT_ORG_SLUG },
-      create: expect.objectContaining({
-        id: DEFAULT_ORG_ID,
-        slug: DEFAULT_ORG_SLUG,
-      }),
-      update: {},
-    });
-
-    expect(workspaceUpsert).toHaveBeenCalledTimes(1);
-    expect(workspaceUpsert).toHaveBeenCalledWith({
-      where: {
-        organizationId_slug: {
-          organizationId: DEFAULT_ORG_ID,
-          slug: DEFAULT_WORKSPACE_SLUG,
-        },
-      },
-      create: expect.objectContaining({
-        id: DEFAULT_WORKSPACE_ID,
-        organizationId: DEFAULT_ORG_ID,
-        slug: DEFAULT_WORKSPACE_SLUG,
-      }),
-      update: {},
-    });
-  });
-
-  it("AC-2: given workspace.count() > 0, makes no organization/workspace create-or-upsert calls and returns { created: false } (multi-tenant / re-run no-op)", async () => {
-    const { prisma, organizationUpsert, workspaceUpsert, workspaceCountFn } =
-      makeStubPrisma(3);
-
-    const result = await provisionDefaultWorkspace(prisma);
-
-    expect(result).toEqual({ created: false });
-    expect(workspaceCountFn).toHaveBeenCalledTimes(1);
-    expect(organizationUpsert).not.toHaveBeenCalled();
-    expect(workspaceUpsert).not.toHaveBeenCalled();
-  });
-});
-
-describe("provisionDefaultWorkspace — the request-quote magnet (#8168 D8, C4, AC-5)", () => {
-  it("upserts the default workspace's draft request-quote magnet, insert-if-absent, after the workspace", async () => {
-    const { prisma, workspaceUpsert, flowDefinitionUpsert } = makeStubPrisma(0);
-
-    await provisionDefaultWorkspace(prisma);
-
-    expect(flowDefinitionUpsert).toHaveBeenCalledTimes(4);
-    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(1, {
-      where: {
-        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: REQUEST_QUOTE_FLOW_SLUG },
-      },
-      create: {
-        siteId: DEFAULT_WORKSPACE_ID,
-        workspaceId: DEFAULT_WORKSPACE_ID,
-        slug: "request-quote",
-        config: requestQuoteFlowConfig,
-        kind: "contact",
-        title: REQUEST_QUOTE_FLOW_TITLE,
-        status: "draft",
-        customersEnabled: true,
-        completion: STANDARD_MAGNET_COMPLETIONS[REQUEST_QUOTE_FLOW_SLUG],
-      },
-      // Empty: an existing (site_id, slug) row is never overwritten (D8, C6).
-      update: {},
-    });
-    expect(workspaceUpsert.mock.invocationCallOrder[0]).toBeLessThan(
-      flowDefinitionUpsert.mock.invocationCallOrder[0] ?? 0,
-    );
-  });
-
-  it("makes no flowDefinition call when a workspace already exists", async () => {
-    const { prisma, flowDefinitionUpsert } = makeStubPrisma(1);
-
-    await provisionDefaultWorkspace(prisma);
-
-    expect(flowDefinitionUpsert).not.toHaveBeenCalled();
-  });
-});
-
-describe("provisionDefaultWorkspace — the Contact form magnet (#8661 D3, AC-1)", () => {
-  it("upserts the default workspace's live Contact form, insert-if-absent", async () => {
-    const { prisma, flowDefinitionUpsert } = makeStubPrisma(0);
-
-    await provisionDefaultWorkspace(prisma);
-
-    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(2, {
-      where: {
-        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: CONTACT_FORM_FLOW_SLUG },
-      },
-      create: {
-        siteId: DEFAULT_WORKSPACE_ID,
-        workspaceId: DEFAULT_WORKSPACE_ID,
-        slug: "contact",
-        config: contactFormFlowConfig,
-        kind: "contact",
-        title: "Contact form",
-        status: "live",
-        customersEnabled: false,
-        completion: STANDARD_MAGNET_COMPLETIONS[CONTACT_FORM_FLOW_SLUG],
-        landingPage: "/contact",
-      },
-      // Empty: a re-run never overwrites the owner's edits.
-      update: {},
-    });
-  });
-
-  it("makes no flowDefinition call when a workspace already exists", async () => {
-    const { prisma, flowDefinitionUpsert } = makeStubPrisma(1);
-
-    await provisionDefaultWorkspace(prisma);
-
-    expect(flowDefinitionUpsert).not.toHaveBeenCalled();
-  });
-});
-
-describe("provisionDefaultWorkspace — the Job application magnet (#8746 D3, AC-2)", () => {
-  it("upserts the default workspace's live Job application, insert-if-absent", async () => {
-    const { prisma, flowDefinitionUpsert } = makeStubPrisma(0);
-
-    await provisionDefaultWorkspace(prisma);
-
-    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(3, {
-      where: {
-        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: JOB_APPLICATION_FLOW_SLUG },
-      },
-      create: {
-        siteId: DEFAULT_WORKSPACE_ID,
-        workspaceId: DEFAULT_WORKSPACE_ID,
-        slug: "job-application",
-        config: jobApplicationFlowConfig,
-        kind: "diagnostic",
-        title: "Job application",
-        status: "live",
-        customersEnabled: false,
-        completion: STANDARD_MAGNET_COMPLETIONS[JOB_APPLICATION_FLOW_SLUG],
-        landingPage: "/careers",
-      },
-      // Empty: a re-run never overwrites the owner's edits.
-      update: {},
-    });
-  });
-});
-
-describe("provisionDefaultWorkspace — the newsletter magnet (#8847 D4, AC-5)", () => {
-  it("upserts the default workspace's live newsletter, insert-if-absent", async () => {
-    const { prisma, flowDefinitionUpsert } = makeStubPrisma(0);
-
-    await provisionDefaultWorkspace(prisma);
-
-    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(4, {
-      where: {
-        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: NEWSLETTER_FLOW_SLUG },
-      },
-      create: {
-        siteId: DEFAULT_WORKSPACE_ID,
-        workspaceId: DEFAULT_WORKSPACE_ID,
-        slug: "newsletter",
-        config: newsletterFlowConfig,
-        kind: "newsletter",
-        title: "Newsletter",
-        status: "live",
-        customersEnabled: false,
-        completion: STANDARD_MAGNET_COMPLETIONS[NEWSLETTER_FLOW_SLUG],
-        landingPage: "/newsletter",
-      },
-      // Empty: a re-run never overwrites the owner's edits.
-      update: {},
-    });
-  });
-});

package/templates/database/__tests__/spoke-registry.db.test.ts

@@ -1,191 +0,0 @@
-/**
- * @file spoke-registry.db.test.ts
- *
- * LIVE-DATABASE proof of the hub's spoke registry and the booking-origin
- * record (#7532, spec docs/specs/7532-a-spoke-s-public-reads-spec.md D1, D5,
- * D8; AC-2). Requires DATABASE_URL pointing at a Postgres with the migrations
- * applied — the whole suite SKIPS when DATABASE_URL is unset, keeping the
- * workspace Jest run DB-free (the repo convention; the
- * `apps/api Route Tests (Postgres)` workflow exercises it).
- *
- * Uses the `pg` driver directly, as `prefixed-ids.db.test.ts` does. What it
- * proves that a mock cannot:
- *   1. The five format CHECKs reject a malformed id.
- *   2. The `appointment_origins` unique key refuses a second origin for one
- *      booking uid.
- *   3. Deleting a workspace cascades its `spokes`.
- *   4. The per-booking advisory lock serializes: while connection A's
- *      transaction holds the lock for uidA, connection B cannot take it, and
- *      can once A commits; a different uid's lock is free throughout.
- */
-import { Client } from "pg";
-
-const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
-
-const V7 = "01920000-0000-7000-8000";
-const LOCK_SQL =
-  "SELECT pg_try_advisory_xact_lock(hashtextextended($1, 0)) AS locked";
-
-describeDb("the spoke registry and booking origins (#7532, live DB)", () => {
-  let a: Client;
-  let b: Client;
-  let workspaceId: string;
-
-  beforeAll(async () => {
-    a = new Client({ connectionString: process.env.DATABASE_URL });
-    b = new Client({ connectionString: process.env.DATABASE_URL });
-    await a.connect();
-    await b.connect();
-
-    const org = (
-      await a.query<{ id: string }>(
-        `INSERT INTO "organizations" ("name", "slug", "updated_at")
-         VALUES ('Spoke Registry Org', 'spoke7532-org', now()) RETURNING "id"`,
-      )
-    ).rows[0]!;
-    workspaceId = (
-      await a.query<{ id: string }>(
-        `INSERT INTO "workspaces" ("organization_id", "name", "slug", "updated_at")
-         VALUES ($1, 'Spoke Registry Workspace', 'spoke7532-ws', now()) RETURNING "id"`,
-        [org.id],
-      )
-    ).rows[0]!.id;
-  });
-
-  afterAll(async () => {
-    await a.query(
-      `DELETE FROM "appointment_origins" WHERE "provider_booking_uid" LIKE 'spoke7532-%'`,
-    );
-    await a.query(`DELETE FROM "organizations" WHERE "slug" LIKE 'spoke7532-%'`);
-    await a.end();
-    await b.end();
-  });
-
-  /** Insert one spoke; the database mints its id. */
-  async function insertSpoke(
-    client: Client,
-    overrides: { id?: string; workspaceId?: string; hash?: string } = {},
-  ): Promise<string> {
-    const { rows } = await client.query<{ id: string }>(
-      `INSERT INTO "spokes" (${overrides.id ? '"id", ' : ""}"workspace_id", "name", "credential_hash", "credential_prefix", "updated_at")
-       VALUES (${overrides.id ? "$4, " : ""}$1, 'acme', $2, $3, now()) RETURNING "id"`,
-      [
-        overrides.workspaceId ?? workspaceId,
-        overrides.hash ?? "a".repeat(64),
-        "ailk_spk_abcdefgh",
-        ...(overrides.id ? [overrides.id] : []),
-      ],
-    );
-    return rows[0]!.id;
-  }
-
-  describe("format CHECKs (ADR-0031)", () => {
-    it("a spoke takes a database-minted spoke_ id", async () => {
-      const id = await insertSpoke(a, { hash: "1".repeat(64) });
-      expect(id).toMatch(/^spoke_[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
-    });
-
-    it("REJECTS a malformed spoke id", async () => {
-      await expect(
-        insertSpoke(a, { id: "bad", hash: "2".repeat(64) }),
-      ).rejects.toThrow(/spokes_id_format/);
-    });
-
-    it("REJECTS a malformed spoke workspace_id", async () => {
-      // The format CHECK fires before the foreign key.
-      await expect(
-        insertSpoke(a, { workspaceId: "not-a-workspace", hash: "3".repeat(64) }),
-      ).rejects.toThrow(/spokes_workspace_id_format/);
-    });
-
-    it.each([
-      ["id", "appointment_origins_id_format"],
-      ["spoke_id", "appointment_origins_spoke_id_format"],
-      ["workspace_id", "appointment_origins_workspace_id_format"],
-    ])("REJECTS a malformed origin %s", async (column, constraint) => {
-      const values: Record<string, string> = {
-        id: `apptorg_${V7}-0000000000e1`,
-        spoke_id: `spoke_${V7}-0000000000c1`,
-        workspace_id: workspaceId,
-      };
-      values[column] = "bad";
-      await expect(
-        a.query(
-          `INSERT INTO "appointment_origins" ("id", "provider_booking_uid", "workspace_id", "spoke_id")
-           VALUES ($1, $2, $3, $4)`,
-          [values["id"], `spoke7532-${column}`, values["workspace_id"], values["spoke_id"]],
-        ),
-      ).rejects.toThrow(new RegExp(constraint));
-    });
-  });
-
-  describe("unique keys", () => {
-    it("a credential digest is unique", async () => {
-      await insertSpoke(a, { hash: "4".repeat(64) });
-      await expect(insertSpoke(a, { hash: "4".repeat(64) })).rejects.toThrow(
-        /spokes_credential_hash_key/,
-      );
-    });
-
-    it("refuses a second origin for one booking uid, and ON CONFLICT DO NOTHING absorbs it", async () => {
-      const insert = (spokeSuffix: string) =>
-        a.query(
-          `INSERT INTO "appointment_origins" ("provider", "provider_booking_uid", "workspace_id", "spoke_id")
-           VALUES ('cal', 'spoke7532-uidA', $1, $2)`,
-          [workspaceId, `spoke_${V7}-0000000000${spokeSuffix}`],
-        );
-      await insert("c1");
-      await expect(insert("c2")).rejects.toThrow(
-        /appointment_origins_provider_provider_booking_uid_key/,
-      );
-
-      const skipped = await a.query(
-        `INSERT INTO "appointment_origins" ("provider", "provider_booking_uid", "workspace_id", "spoke_id")
-         VALUES ('cal', 'spoke7532-uidA', $1, $2) ON CONFLICT DO NOTHING`,
-        [workspaceId, `spoke_${V7}-0000000000c3`],
-      );
-      expect(skipped.rowCount).toBe(0);
-    });
-  });
-
-  it("deleting a workspace deletes its spokes", async () => {
-    const org = (
-      await a.query<{ id: string }>(
-        `INSERT INTO "organizations" ("name", "slug", "updated_at")
-         VALUES ('Cascade Org', 'spoke7532-cascade', now()) RETURNING "id"`,
-      )
-    ).rows[0]!;
-    const doomed = (
-      await a.query<{ id: string }>(
-        `INSERT INTO "workspaces" ("organization_id", "name", "slug", "updated_at")
-         VALUES ($1, 'Doomed', 'doomed', now()) RETURNING "id"`,
-        [org.id],
-      )
-    ).rows[0]!.id;
-    const spokeId = await insertSpoke(a, { workspaceId: doomed, hash: "5".repeat(64) });
-
-    await a.query(`DELETE FROM "workspaces" WHERE "id" = $1`, [doomed]);
-
-    const { rowCount } = await a.query(`SELECT 1 FROM "spokes" WHERE "id" = $1`, [spokeId]);
-    expect(rowCount).toBe(0);
-  });
-
-  it("the per-booking advisory lock serializes one uid and leaves another free", async () => {
-    const keyA = "appointment:cal:spoke7532-uidA";
-    const keyB = "appointment:cal:spoke7532-uidB";
-
-    await a.query("BEGIN");
-    await a.query("SELECT pg_advisory_xact_lock(hashtextextended($1, 0))", [keyA]);
-
-    await b.query("BEGIN");
-    expect((await b.query(LOCK_SQL, [keyA])).rows[0].locked).toBe(false);
-    expect((await b.query(LOCK_SQL, [keyB])).rows[0].locked).toBe(true);
-    await b.query("COMMIT");
-
-    await a.query("COMMIT");
-
-    await b.query("BEGIN");
-    expect((await b.query(LOCK_SQL, [keyA])).rows[0].locked).toBe(true);
-    await b.query("COMMIT");
-  });
-});

package/templates/database/__tests__/tenancy.test.ts

@@ -1,141 +0,0 @@
-/**
- * @file tenancy.test.ts
- * @description Unit coverage for `resolveDefaultWorkspaceRow` — the shared
- * one-workspace deployment predicate (#5876 spec D2) — over a structural
- * `WorkspacePredicateClient` stub. No `@prisma/client` import anywhere in
- * this file or in `../tenancy.ts`; the four arms below are the same ones
- * `apps/api/src/services/__tests__/public-site-resolver.test.ts` and
- * `apps/api/src/middleware/__tests__/default-tenant.test.ts` already pin for
- * the re-pointed caller — this suite is the predicate's OWN coverage.
- *
- * `resolveSentinelWorkspaceRow` (#6155 spec D2 rule 2) is the sibling
- * sentinel-EXISTENCE predicate, covered below on the SAME three-workspace
- * mock that `resolveDefaultWorkspaceRow` refuses — the pair is what proves
- * the two questions ("is this deployment single-tenant" vs "does the
- * sentinel workspace exist") stay separate rather than re-merging.
- */
-
-import {
-  DEFAULT_ORG_ID,
-  DEFAULT_WORKSPACE_ID,
-  resolveDefaultWorkspaceRow,
-  resolveSentinelWorkspaceRow,
-  type WorkspacePredicateClient,
-} from "../tenancy";
-
-const NON_SENTINEL_ORG_ID = "org_01930000-0000-7bcd-8000-000000000002";
-
-function makeStub(
-  count: number,
-  found: { organizationId: string } | null,
-): WorkspacePredicateClient {
-  return {
-    workspace: {
-      count: jest.fn().mockResolvedValue(count),
-      findUnique: jest.fn().mockResolvedValue(found),
-    },
-  };
-}
-
-describe("resolveDefaultWorkspaceRow", () => {
-  it("returns null when zero workspaces exist (count() === 0)", async () => {
-    const stub = makeStub(0, null);
-
-    const result = await resolveDefaultWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-    // The deployment is ambiguous at the count check alone — findUnique must
-    // never run.
-    expect(stub.workspace.findUnique).not.toHaveBeenCalled();
-  });
-
-  it("returns null when two or more workspaces exist (count() === 2)", async () => {
-    const stub = makeStub(2, null);
-
-    const result = await resolveDefaultWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-    expect(stub.workspace.findUnique).not.toHaveBeenCalled();
-  });
-
-  it("returns null when the sole workspace hangs off a non-sentinel Organization", async () => {
-    const stub = makeStub(1, { organizationId: NON_SENTINEL_ORG_ID });
-
-    const result = await resolveDefaultWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-  });
-
-  it("returns null when the sole workspace is not found at the default id", async () => {
-    const stub = makeStub(1, null);
-
-    const result = await resolveDefaultWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-  });
-
-  it("returns the row when the sole workspace is the well-known default hanging off the sentinel Organization", async () => {
-    const stub = makeStub(1, { organizationId: DEFAULT_ORG_ID });
-
-    const result = await resolveDefaultWorkspaceRow(stub);
-
-    expect(result).toEqual({
-      id: DEFAULT_WORKSPACE_ID,
-      organizationId: DEFAULT_ORG_ID,
-    });
-    expect(stub.workspace.findUnique).toHaveBeenCalledWith({
-      where: { id: DEFAULT_WORKSPACE_ID },
-    });
-  });
-
-  it("returns null on a THREE-workspace deployment even though the sentinel workspace exists — the count gate refuses it before findUnique ever runs", async () => {
-    // A correctly-configured multi-workspace deployment: the sentinel is one
-    // of three, but resolveDefaultWorkspaceRow answers "is this deployment
-    // unambiguously single-tenant", not "does the sentinel exist" — #6155
-    // spec D2/R1, the exact case resolveSentinelWorkspaceRow exists for.
-    const stub = makeStub(3, { organizationId: DEFAULT_ORG_ID });
-
-    const result = await resolveDefaultWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-    expect(stub.workspace.findUnique).not.toHaveBeenCalled();
-  });
-});
-
-describe("resolveSentinelWorkspaceRow", () => {
-  it("resolves the sentinel workspace on a THREE-workspace deployment — no count() gate", async () => {
-    // The SAME three-workspace mock resolveDefaultWorkspaceRow refuses above
-    // — this is the pair that keeps the two questions separate (#6155 D2
-    // rule 2): resolveDefaultWorkspaceRow answers "is this deployment
-    // single-tenant" (no); resolveSentinelWorkspaceRow answers "does the
-    // seeded sentinel workspace exist" (yes), and it never calls count().
-    const stub = makeStub(3, { organizationId: DEFAULT_ORG_ID });
-
-    const result = await resolveSentinelWorkspaceRow(stub);
-
-    expect(result).toEqual({
-      id: DEFAULT_WORKSPACE_ID,
-      organizationId: DEFAULT_ORG_ID,
-    });
-    expect(stub.workspace.count).not.toHaveBeenCalled();
-    expect(stub.workspace.findUnique).toHaveBeenCalledWith({
-      where: { id: DEFAULT_WORKSPACE_ID },
-    });
-  });
-
-  it("returns null when no workspace carries the sentinel id", async () => {
-    const stub = makeStub(3, null);
-
-    const result = await resolveSentinelWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-  });
-
-  it("returns null when the id resolves but hangs off a non-sentinel Organization", async () => {
-    const stub = makeStub(3, { organizationId: NON_SENTINEL_ORG_ID });
-
-    const result = await resolveSentinelWorkspaceRow(stub);
-
-    expect(result).toBeNull();
-  });
-});