ddd-ts-kit 0.14.0 → 0.16.0

package/templates/presets/identity/context/presentation/http/organisations/grant-delegation/grant-delegation.controller.ts.tpl

@@ -0,0 +1,103 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { GrantDelegationCommand } from '{{alias.context}}/application/commands/grant-delegation/grant-delegation.command{{alias.ext}}';
+import { GrantDelegationParams } from '{{alias.context}}/presentation/http/organisations/grant-delegation/grant-delegation.params{{alias.ext}}';
+import { GrantDelegationBody } from '{{alias.context}}/presentation/http/organisations/grant-delegation/grant-delegation.body{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { GrantDelegationAccepted } from '{{alias.context}}/presentation/http/organisations/grant-delegation/grant-delegation.accepted{{alias.ext}}';
+{{/if}}
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { GrantDelegationCommand } from '{{alias.context}}/application/commands/grant-delegation/grant-delegation.command{{alias.ext}}';
+import { MemberRight } from '{{alias.context}}/domain/vocabularies/member-right.vocabulary{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const params = classSchema(GrantDelegationParams);
+const body = classSchema(GrantDelegationBody);
+{{#if schemas.perRoute}}
+const accepted = classSchema(GrantDelegationAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+const params = zodSchema(
+  z.object({
+    organisationId: z.string().min(1),
+  }),
+);
+
+const body = zodSchema(
+  z.object({
+    delegateId: z.string().min(1),
+    rights: z.array(z.enum(MemberRight)).min(1),
+    startsAt: z.iso.datetime(),
+    endsAt: z.iso.datetime(),
+  }),
+);
+
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'POST',
+  path: '/:organisationId/delegations',
+  summary: 'Lend rights to a member',
+  params,
+  body,
+  response: { status: 201, description: 'Granted; the body carries the identifier of the delegation.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: [
+    'MEMBER_NOT_FOUND',
+    'DELEGATION_TO_ONESELF',
+    'DELEGATION_WITHOUT_RIGHTS',
+    'DELEGATION_BEYOND_RIGHTS',
+    'DELEGATION_PERIOD_INVERTED',
+    'DELEGATION_TOO_LONG',
+  ],
+})
+export class GrantDelegationController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ params: GrantDelegationParams; body: GrantDelegationBody }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}GrantDelegationAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ params: Infer<typeof params>; body: Infer<typeof body> }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new GrantDelegationCommand(request.actor, request.params.organisationId, termsOf(request.body)));
+
+    return { id };
+  }
+}
+
+{{#if validation.classValidator}}
+function termsOf({ delegateId, rights, startsAt, endsAt }: GrantDelegationBody): GrantDelegationCommand['terms'] {
+  return { delegateId, rights, startsAt: new Date(startsAt), endsAt: new Date(endsAt) };
+}
+{{/if}}
+{{#if validation.zod}}
+function termsOf({ delegateId, rights, startsAt, endsAt }: Infer<typeof body>): GrantDelegationCommand['terms'] {
+  return { delegateId, rights, startsAt: new Date(startsAt), endsAt: new Date(endsAt) };
+}
+{{/if}}

package/templates/presets/identity/context/presentation/http/organisations/grant-delegation/grant-delegation.params.class-validator.ts.tpl

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class GrantDelegationParams {
+  @IsString()
+  @IsNotEmpty()
+  organisationId = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/invite-member/invite-member.accepted.class-validator.ts.tpl

@@ -0,0 +1,10 @@
+import { IsString } from 'class-validator';
+
+export class InviteMemberAccepted {
+  @IsString()
+  id = '';
+
+  /** The token to send to the person, once: only its digest is stored. */
+  @IsString()
+  token = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/invite-member/invite-member.body.class-validator.ts.tpl

@@ -0,0 +1,10 @@
+import { IsEmail, IsIn } from 'class-validator';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+
+export class InviteMemberBody {
+  @IsEmail()
+  email = '';
+
+  @IsIn(Object.values(MemberRole))
+  role: MemberRole = MemberRole.Member;
+}

package/templates/presets/identity/context/presentation/http/organisations/invite-member/invite-member.controller.ts.tpl

@@ -0,0 +1,65 @@
+{{#if validation.classValidator}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { InviteMemberCommand } from '{{alias.context}}/application/commands/invite-member/invite-member.command{{alias.ext}}';
+import { InviteMemberParams } from '{{alias.context}}/presentation/http/organisations/invite-member/invite-member.params{{alias.ext}}';
+import { InviteMemberBody } from '{{alias.context}}/presentation/http/organisations/invite-member/invite-member.body{{alias.ext}}';
+import { InviteMemberAccepted } from '{{alias.context}}/presentation/http/organisations/invite-member/invite-member.accepted{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { InviteMemberCommand } from '{{alias.context}}/application/commands/invite-member/invite-member.command{{alias.ext}}';
+import { MemberRole } from '{{alias.context}}/domain/vocabularies/member-role.vocabulary{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const params = classSchema(InviteMemberParams);
+const body = classSchema(InviteMemberBody);
+const accepted = classSchema(InviteMemberAccepted);
+{{/if}}
+{{#if validation.zod}}
+const params = zodSchema(
+  z.object({
+    organisationId: z.string().min(1),
+  }),
+);
+
+const body = zodSchema(
+  z.object({
+    email: z.email(),
+    role: z.enum(MemberRole),
+  }),
+);
+
+const accepted = zodSchema(z.object({ id: z.string(), token: z.string() }), { io: 'output' });
+{{/if}}
+
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'POST',
+  path: '/:organisationId/invitations',
+  summary: 'Invite a person to the organisation',
+  params,
+  body,
+  response: { status: 201, description: 'Issued; the body carries the token to send to the person, given once and never stored.', body: accepted },
+  errors: ['INVALID_EMAIL_ADDRESS', 'ABOVE_OWN_ROLE', 'OWNERS_ONLY'],
+})
+export class InviteMemberController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ params: InviteMemberParams; body: InviteMemberBody }>): Promise<InviteMemberAccepted> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ params: Infer<typeof params>; body: Infer<typeof body> }>): Promise<Infer<typeof accepted>> {
+{{/if}}
+    return this.commands.execute(new InviteMemberCommand(request.actor, request.params.organisationId, request.body));
+  }
+}

package/templates/presets/identity/context/presentation/http/organisations/invite-member/invite-member.params.class-validator.ts.tpl

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class InviteMemberParams {
+  @IsString()
+  @IsNotEmpty()
+  organisationId = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/open-organisation/open-organisation.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class OpenOrganisationAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/open-organisation/open-organisation.body.class-validator.ts.tpl

@@ -0,0 +1,12 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class OpenOrganisationBody {
+  /** Lower-case letters, digits and hyphens: the identifier of the organisation, for good. */
+  @IsString()
+  @IsNotEmpty()
+  slug = '';
+
+  @IsString()
+  @IsNotEmpty()
+  name = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/open-organisation/open-organisation.controller.ts.tpl

@@ -0,0 +1,79 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { OpenOrganisationCommand } from '{{alias.context}}/application/commands/open-organisation/open-organisation.command{{alias.ext}}';
+import { OpenOrganisationBody } from '{{alias.context}}/presentation/http/organisations/open-organisation/open-organisation.body{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { OpenOrganisationAccepted } from '{{alias.context}}/presentation/http/organisations/open-organisation/open-organisation.accepted{{alias.ext}}';
+{{/if}}
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { OpenOrganisationCommand } from '{{alias.context}}/application/commands/open-organisation/open-organisation.command{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const body = classSchema(OpenOrganisationBody);
+{{#if schemas.perRoute}}
+const accepted = classSchema(OpenOrganisationAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+const body = zodSchema(
+  z.object({
+    slug: z.string().min(1),
+    name: z.string().min(1),
+  }),
+);
+
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'POST',
+  path: '/',
+  summary: 'Open an organisation',
+  body,
+  response: { status: 201, description: 'Opened; the body carries its slug, the caller is its first owner.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: [
+    'ACCOUNT_NOT_FOUND',
+    'ACCOUNT_DEACTIVATED',
+    'ORGANISATION_SLUG_TAKEN',
+    'INVALID_ORGANISATION_SLUG',
+    'INVALID_ORGANISATION_NAME',
+  ],
+})
+export class OpenOrganisationController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ body: OpenOrganisationBody }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}OpenOrganisationAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ body: Infer<typeof body> }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new OpenOrganisationCommand(request.actor, request.body));
+
+    return { id };
+  }
+}

package/templates/presets/identity/context/presentation/http/organisations/remove-member/remove-member.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class RemoveMemberAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/remove-member/remove-member.controller.ts.tpl

@@ -0,0 +1,73 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { RemoveMemberCommand } from '{{alias.context}}/application/commands/remove-member/remove-member.command{{alias.ext}}';
+import { RemoveMemberParams } from '{{alias.context}}/presentation/http/organisations/remove-member/remove-member.params{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { RemoveMemberAccepted } from '{{alias.context}}/presentation/http/organisations/remove-member/remove-member.accepted{{alias.ext}}';
+{{/if}}
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { RemoveMemberCommand } from '{{alias.context}}/application/commands/remove-member/remove-member.command{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const params = classSchema(RemoveMemberParams);
+{{#if schemas.perRoute}}
+const accepted = classSchema(RemoveMemberAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+const params = zodSchema(
+  z.object({
+    organisationId: z.string().min(1),
+    accountId: z.string().min(1),
+  }),
+);
+
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'DELETE',
+  path: '/:organisationId/members/:accountId',
+  summary: 'Remove a member',
+  params,
+  response: { status: 200, description: 'Removed; the body carries the identifier of the membership.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: ['ORGANISATION_NOT_FOUND', 'MEMBER_NOT_FOUND', 'ABOVE_OWN_ROLE', 'OWNERS_ONLY', 'LAST_OWNER'],
+})
+export class RemoveMemberController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ params: RemoveMemberParams }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}RemoveMemberAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ params: Infer<typeof params> }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new RemoveMemberCommand(request.actor, request.params.organisationId, request.params.accountId));
+
+    return { id };
+  }
+}

package/templates/presets/identity/context/presentation/http/organisations/remove-member/remove-member.params.class-validator.ts.tpl

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class RemoveMemberParams {
+  @IsString()
+  @IsNotEmpty()
+  organisationId = '';
+
+  @IsString()
+  @IsNotEmpty()
+  accountId = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/revoke-delegation/revoke-delegation.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class RevokeDelegationAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/revoke-delegation/revoke-delegation.controller.ts.tpl

@@ -0,0 +1,73 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { RevokeDelegationCommand } from '{{alias.context}}/application/commands/revoke-delegation/revoke-delegation.command{{alias.ext}}';
+import { RevokeDelegationParams } from '{{alias.context}}/presentation/http/organisations/revoke-delegation/revoke-delegation.params{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { RevokeDelegationAccepted } from '{{alias.context}}/presentation/http/organisations/revoke-delegation/revoke-delegation.accepted{{alias.ext}}';
+{{/if}}
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { RevokeDelegationCommand } from '{{alias.context}}/application/commands/revoke-delegation/revoke-delegation.command{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const params = classSchema(RevokeDelegationParams);
+{{#if schemas.perRoute}}
+const accepted = classSchema(RevokeDelegationAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+const params = zodSchema(
+  z.object({
+    organisationId: z.string().min(1),
+    delegationId: z.string().min(1),
+  }),
+);
+
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'DELETE',
+  path: '/:organisationId/delegations/:delegationId',
+  summary: 'Revoke a delegation',
+  params,
+  response: { status: 200, description: 'Revoked; the body carries its identifier.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: ['DELEGATION_NOT_FOUND', 'DELEGATION_NOT_ACTIVE'],
+})
+export class RevokeDelegationController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ params: RevokeDelegationParams }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}RevokeDelegationAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ params: Infer<typeof params> }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new RevokeDelegationCommand(request.actor, request.params.organisationId, request.params.delegationId));
+
+    return { id };
+  }
+}

package/templates/presets/identity/context/presentation/http/organisations/revoke-delegation/revoke-delegation.params.class-validator.ts.tpl

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class RevokeDelegationParams {
+  @IsString()
+  @IsNotEmpty()
+  organisationId = '';
+
+  @IsString()
+  @IsNotEmpty()
+  delegationId = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/revoke-invitation/revoke-invitation.accepted.class-validator.per-route.ts.tpl

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class RevokeInvitationAccepted {
+  @IsString()
+  id = '';
+}

package/templates/presets/identity/context/presentation/http/organisations/revoke-invitation/revoke-invitation.controller.ts.tpl

@@ -0,0 +1,73 @@
+{{#if validation.classValidator}}
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import { classSchema } from '@ddd-ts-kit/validation/class-validator';
+import { RevokeInvitationCommand } from '{{alias.context}}/application/commands/revoke-invitation/revoke-invitation.command{{alias.ext}}';
+import { RevokeInvitationParams } from '{{alias.context}}/presentation/http/organisations/revoke-invitation/revoke-invitation.params{{alias.ext}}';
+{{#if schemas.perRoute}}
+import { RevokeInvitationAccepted } from '{{alias.context}}/presentation/http/organisations/revoke-invitation/revoke-invitation.accepted{{alias.ext}}';
+{{/if}}
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+{{#if validation.zod}}
+import { z } from 'zod';
+{{#if schemas.shared}}
+import { acceptedSchema, Controller, type Accepted, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if schemas.perRoute}}
+import { Controller, type HttpRequest } from '@ddd-ts-kit/http';
+{{/if}}
+import type { CommandBus } from '@ddd-ts-kit/kernel';
+import type { Infer } from '@ddd-ts-kit/validation';
+import { zodSchema } from '@ddd-ts-kit/validation/zod';
+import { RevokeInvitationCommand } from '{{alias.context}}/application/commands/revoke-invitation/revoke-invitation.command{{alias.ext}}';
+import { OrganisationsRoutes } from '{{alias.context}}/presentation/http/organisations.routes{{alias.ext}}';
+{{/if}}
+
+{{#if validation.classValidator}}
+const params = classSchema(RevokeInvitationParams);
+{{#if schemas.perRoute}}
+const accepted = classSchema(RevokeInvitationAccepted);
+{{/if}}
+{{/if}}
+{{#if validation.zod}}
+const params = zodSchema(
+  z.object({
+    organisationId: z.string().min(1),
+    invitationId: z.string().min(1),
+  }),
+);
+
+{{#if schemas.perRoute}}
+const accepted = zodSchema(z.object({ id: z.string() }), { io: 'output' });
+{{/if}}
+{{/if}}
+
+@Controller({
+  group: OrganisationsRoutes,
+  method: 'DELETE',
+  path: '/:organisationId/invitations/:invitationId',
+  summary: 'Take back an invitation',
+  params,
+  response: { status: 200, description: 'Taken back; the body carries its identifier.', body: {{#if schemas.shared}}acceptedSchema{{/if}}{{#if schemas.perRoute}}accepted{{/if}} },
+  errors: ['INVITATION_NOT_FOUND', 'INVITATION_NOT_PENDING'],
+})
+export class RevokeInvitationController {
+  constructor(private readonly commands: CommandBus) {}
+
+{{#if validation.classValidator}}
+  async handle(request: HttpRequest<{ params: RevokeInvitationParams }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}RevokeInvitationAccepted{{/if}}> {
+{{/if}}
+{{#if validation.zod}}
+  async handle(request: HttpRequest<{ params: Infer<typeof params> }>): Promise<{{#if schemas.shared}}Accepted{{/if}}{{#if schemas.perRoute}}Infer<typeof accepted>{{/if}}> {
+{{/if}}
+    const id = await this.commands.execute(new RevokeInvitationCommand(request.actor, request.params.organisationId, request.params.invitationId));
+
+    return { id };
+  }
+}

package/templates/presets/identity/context/presentation/http/organisations/revoke-invitation/revoke-invitation.params.class-validator.ts.tpl

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class RevokeInvitationParams {
+  @IsString()
+  @IsNotEmpty()
+  organisationId = '';
+
+  @IsString()
+  @IsNotEmpty()
+  invitationId = '';
+}