type CustomerSegment = {
  // ...customer segment attributes
};

type Customer = {
  // ...customer attributes
  segment: CustomerSegment;
};

type ContractDraft = {
  // ... draft details
  id: string;
  author: Employee;
  status: "draft" | "submitted" | "reviewed" | "reworked" | "signed-off";
  customer: Customer;
  details: ContractDraftDetails;
};

type Feedback = {
  // ... feedback details
  author: Employee;
  subject: ContractDraft;
};

type Contract = {
  // ... contract details,
  author: Employee;
  approver: Employee;
  customer: Customer;
};

type PortForDraftingContracts = (
  command: DraftContractCommand,
) => Promise<void>;

type DraftContractCommand = {
  author: Employee;
  customer: Customer;
  details: { /*...*/ };
};

const draftContract: PortForDraftingContracts = async ({
  author,
  customer,
  details,
}) => {
  /* ... */
};

function createDraftContractUseCase(
  dependencies: DraftContractDependencies,
): PortForDraftingContracts {
  return async function draftContract(cmd) {
    if (!isSalesperson(cmd.author) { 
        throw new AuthorizationError(...)
    }
    if (!isValidDraftContractCommand(cmd)) { 
      	throw new ValidationError(...)
    }

    await dependencies.contractDrafts.create({
      ...cmd,
      status: "draft",
    });
  };
}

type DraftContractDependencies = {
  contractDrafts: PortForManagingContractDrafts;
};

type ContractDraftInsertDTO = {/*...*/};

type PortForManagingContractDrafts = {
  create(
  	contractDraftInsert: ContractDraftInsertDTO
  ): Promise<void>;
  findById(...): Promise<ContractDraft | undefined>;
};

interface PortForDraftingContracts {
  execute(command: DraftContractCommand): Promise<void>;
}

class DraftContractUseCase implements PortForDraftingContracts {
  constructor(dependencies: DraftContractDependencies) {
    //...
  }

  async execute({ author, details }) {
    //...
  }
}

function createApproveContractDraftUseCase(dependencies: {
  contractDrafts: PortForManagingContractDrafts;
  contracts: PortForManagingContracts;
}): PortForApprovingContractDrafts {
  return async function approveContractDraft({ approver, contractDraftId }) {
    if (!isSalesSupervisor()) { /* error */}

    const contractDraft = await dependencies.contractDrafts.findById(contractDraftId);

    if (!exists(contractDraft)) { /* error */ }
    if (!isSubmitted(contractDraft)) {/* error */}

    await dependencies.contractDrafts.update(contractDraftId, { status: "signed-off" })
    
    await dependencies.contracts.storeContract({ /* ... new contract details */ });
  };
}

type PortForManagingContractDrafts = {
  create(
  	contractDraftInsert: ContractDraftInsertDTO
  ): Promise<void>;
  findById(...): Promise<ContractDraft | undefined>;
};

export function createSqliteContractDraftAdapter(dependencies: {
  db: Database;
}): PortForManagingContractDrafts {
  return {
    async create(contractDraftInsert) {
      dependencies.db
        .insert(contractDrafts)
        .values(toNewContractDraftRow(contractDraftInsert))
        .run();
    },
    async findById(contractDraftId) { /* ... */ },
  };
}

import { form, getRequestEvent } from "$app/server";

const createContractDraft = form(
  DraftContractInputDTOSchema, // https://standardschema.dev/ compliant
  async ({ customerId, title, ...rest }) => {
    const { locals } = getRequestEvent();

    try {
      await locals.draftContract({
        author: locals.currentEmployee,
        customer: await locals.loadCustomer(customerId),
        details: { title, ...rest },
      });
      return { success: true };
    } catch (e) {
      return { success: false, error: e.message };
    }
  },
);

<script lang="ts">
	import { createContractDraft } from 'contractDrafts.remote.ts';
</script>

<h1>Create a new contract draft</h1>

<form {...createContractDraft}>
	<!-- form content goes here -->

	<button>Publish!</button>
</form>

const databaseClient = createDatabaseClient({ url: ".bossmove.db" });

const container = createContainer().register({
  db: asValue(databaseClient.db),
  contractDrafts: asFunction(createSqliteContractDraftAdapter),
  contracts: asFunction(createSqliteContractAdapter),
  approveContractDraft: asFunction(createApproveContractDraftUseCase),
});

const app = express();

app.post("/contract-drafts/:id/approval", async (req, res) => {
  const approveContractDraft = container.resolve("approveContractDraft");
  await approveContractDraft({
    approver: req.user,
    contractDraftId: req.params.id,
  });
  res.send();
});