@1mtx/did-api-contract 1.0.1 → 1.1.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/index.ts
-import { initContract as initContract5 } from "@ts-rest/core";
+import { initContract as initContract9 } from "@ts-rest/core";
 
 // src/v1/auth.ts
 import { initContract } from "@ts-rest/core";
@@ -7,7 +7,7 @@ import { z } from "zod";
 var c = initContract();
 var AuthScheme = z.enum(["eip191"]);
 var VerifyRequestSchema = z.object({
-  did: z.string().min(1).describe("DID of the authenticating user (e.g. `did:ethr:0xABC...`)"),
+  did: z.string().min(1).describe("DID of the authenticating user (e.g. `did:ethr:0xABC...` or `did:vbsn:0xABC...`)"),
   signature: z.string().min(1).describe(
     "Hex signature of the `message` string, produced by the scheme specified in the message"
   ),
@@ -40,7 +40,7 @@ var authContract = c.router({
       "|----------|-------|",
       '| **Signing scheme** | ECDSA secp256k1 (`scheme: "eip191"`) |',
       "| **Signature format** | [EIP-191](https://eips.ethereum.org/EIPS/eip-191) `personal_sign` (65-byte `r\u2016s\u2016v`, hex-encoded with `0x` prefix) |",
-      "| **DID method** | `did:ethr` \u2014 the Ethereum address in the DID must match the signer |",
+      "| **DID method** | `did:ethr` or `did:vbsn` \u2014 the Ethereum address in the DID must match the signer |",
       "| **Message encoding** | UTF-8 JSON string |",
       "",
       "### Steps",
@@ -86,28 +86,37 @@ import { initContract as initContract2 } from "@ts-rest/core";
 import { z as z2 } from "zod";
 var c2 = initContract2();
 var SUPPORTED_FIELDS = [
+  "documentNumber",
   "fullName",
-  "age",
-  "portrait",
+  "dateOfBirth",
   "gender",
   "nationality",
+  "ethnicity",
+  "hometown",
   "permanentAddress",
-  "documentNumber"
+  "identifyingMarks",
+  "issueDate",
+  "expiryDate",
+  "fatherName",
+  "motherName",
+  "photo"
 ];
 var CreateEventSchema = z2.object({
   name: z2.string().min(1).max(255).describe("T\xEAn s\u1EF1 ki\u1EC7n"),
-  coverImageUrl: z2.string().url().optional().describe("\u1EA2nh b\xECa s\u1EF1 ki\u1EC7n"),
+  coverImageId: z2.string().optional().describe("ID \u1EA3nh b\xECa s\u1EF1 ki\u1EC7n"),
   description: z2.string().optional().describe("M\xF4 t\u1EA3 s\u1EF1 ki\u1EC7n"),
   maxGuests: z2.number().int().positive().describe("S\u1ED1 l\u01B0\u1EE3ng kh\xE1ch t\u1ED1i \u0111a"),
-  dateTime: z2.string().datetime().describe("Th\u1EDDi gian di\u1EC5n ra s\u1EF1 ki\u1EC7n"),
+  startDateTime: z2.string().datetime().describe("Th\u1EDDi gian b\u1EAFt \u0111\u1EA7u s\u1EF1 ki\u1EC7n"),
+  endDateTime: z2.string().datetime().describe("Th\u1EDDi gian k\u1EBFt th\xFAc s\u1EF1 ki\u1EC7n"),
   requestedFields: z2.array(z2.enum(SUPPORTED_FIELDS)).min(1).describe("C\xE1c tr\u01B0\u1EDDng d\u1EEF li\u1EC7u y\xEAu c\u1EA7u x\xE1c th\u1EF1c")
 });
 var UpdateEventSchema = z2.object({
   name: z2.string().min(1).max(255).optional(),
-  coverImageUrl: z2.string().nullable().optional(),
+  coverImageId: z2.string().nullable().optional(),
   description: z2.string().nullable().optional(),
   maxGuests: z2.number().int().positive().optional(),
-  dateTime: z2.string().datetime().optional(),
+  startDateTime: z2.string().datetime().optional(),
+  endDateTime: z2.string().datetime().optional(),
   status: z2.enum(["ACTIVE", "CANCELLED", "COMPLETED"]).optional()
 });
 var ParticipantSchema = z2.object({
@@ -120,9 +129,11 @@ var EventResponseSchema = z2.object({
   id: z2.string(),
   name: z2.string(),
   coverImageUrl: z2.string().nullable(),
+  thumbnailUrl: z2.string().nullable(),
   description: z2.string().nullable(),
   maxGuests: z2.number(),
-  dateTime: z2.string(),
+  startDateTime: z2.string(),
+  endDateTime: z2.string().nullable(),
   userId: z2.string(),
   requestedFields: z2.array(z2.string()),
   status: z2.enum(["ACTIVE", "CANCELLED", "COMPLETED"]),
@@ -134,8 +145,27 @@ var EventDetailResponseSchema = EventResponseSchema.extend({
   participants: z2.array(ParticipantSchema),
   vpRequest: z2.record(z2.unknown())
 });
+var EventDiscoverSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  coverImageUrl: z2.string().nullable(),
+  thumbnailUrl: z2.string().nullable(),
+  description: z2.string().nullable(),
+  startDateTime: z2.string(),
+  endDateTime: z2.string().nullable(),
+  participantCount: z2.number()
+});
 var SECURITY = [{ bearerAuth: [] }];
 var eventsContract = c2.router({
+  discover: {
+    method: "GET",
+    path: "/v1/events/public/discover",
+    responses: {
+      200: z2.array(EventDiscoverSchema)
+    },
+    summary: "List public events for discovery (public)",
+    metadata: { openApiTags: ["Events"], openApiSecurity: [] }
+  },
   create: {
     method: "POST",
     path: "/v1/events",
@@ -219,9 +249,11 @@ var EventPublicInfoSchema = z3.object({
   id: z3.string(),
   name: z3.string(),
   coverImageUrl: z3.string().nullable(),
+  thumbnailUrl: z3.string().nullable(),
   description: z3.string().nullable(),
   maxGuests: z3.number(),
-  dateTime: z3.string(),
+  startDateTime: z3.string(),
+  endDateTime: z3.string().nullable(),
   currentGuests: z3.number(),
   status: z3.enum(["ACTIVE", "CANCELLED", "COMPLETED"])
 });
@@ -255,11 +287,12 @@ var checkinContract = c3.router({
     responses: {
       200: CheckinSubmitResponseSchema,
       400: z3.object({ message: z3.string(), errors: z3.array(z3.string()).optional() }),
+      401: z3.object({ message: z3.string() }),
       404: z3.object({ message: z3.string() }),
       409: z3.object({ message: z3.string() })
     },
-    summary: "Submit VP for event check-in \u2014 issues participation VC on success (public)",
-    metadata: { openApiTags: ["Check-in"], openApiSecurity: [] }
+    summary: "Submit VP for event check-in \u2014 issues participation VC on success",
+    metadata: { openApiTags: ["Check-in"], openApiSecurity: [{ bearerAuth: [] }] }
   },
   myCheckins: {
     method: "GET",
@@ -270,6 +303,7 @@ var checkinContract = c3.router({
           id: z3.string(),
           eventId: z3.string(),
           checkedInAt: z3.string(),
+          disclosedFields: z3.record(z3.unknown()),
           event: EventPublicInfoSchema
         })
       ),
@@ -306,14 +340,401 @@ var turnContract = c4.router({
   }
 });
 
-// src/index.ts
+// src/v1/uploads.ts
+import { initContract as initContract5 } from "@ts-rest/core";
+import { z as z5 } from "zod";
 var c5 = initContract5();
-var contract = c5.router({
-  v1: c5.router({
+var UploadPresignedUrlSchema = z5.object({
+  fileId: z5.string(),
+  original: z5.object({
+    uploadUrl: z5.string(),
+    key: z5.string(),
+    publicUrl: z5.string()
+  }),
+  resize: z5.object({
+    uploadUrl: z5.string(),
+    key: z5.string(),
+    publicUrl: z5.string()
+  })
+});
+var uploadsContract = c5.router(
+  {
+    generatePresignedUrls: {
+      method: "POST",
+      path: "/urls",
+      body: z5.object({}),
+      responses: {
+        201: UploadPresignedUrlSchema
+      },
+      summary: "Generate pre-signed URLs for event image upload",
+      metadata: { openApiTags: ["Uploads"], openApiSecurity: [{ bearerAuth: [] }] }
+    }
+  },
+  {
+    pathPrefix: "/v1/uploads"
+  }
+);
+
+// src/v1/tracking.ts
+import { initContract as initContract6 } from "@ts-rest/core";
+import { z as z6 } from "zod";
+var c6 = initContract6();
+var TrackScanRequestSchema = z6.object({
+  platform: z6.string(),
+  appVersion: z6.string().optional()
+});
+var TrackScanResponseSchema = z6.object({
+  id: z6.string()
+});
+var trackingContract = c6.router({
+  scan: {
+    method: "POST",
+    path: "/v1/tracking/scan",
+    body: TrackScanRequestSchema,
+    responses: {
+      201: TrackScanResponseSchema,
+      401: z6.object({ message: z6.string() })
+    },
+    summary: "Record a successful NFC scan event",
+    metadata: { openApiTags: ["Tracking"], openApiSecurity: [{ bearerAuth: [] }] }
+  }
+});
+
+// src/v1/config.ts
+import { initContract as initContract7 } from "@ts-rest/core";
+import { z as z7 } from "zod";
+var c7 = initContract7();
+var appConfigContract = c7.router({
+  appConfig: {
+    method: "GET",
+    path: "/v1/config/app",
+    responses: {
+      200: z7.object({
+        demoMode: z7.object({ enabled: z7.boolean() }),
+        publicEvents: z7.object({ enabled: z7.boolean() })
+      })
+    },
+    summary: "Get app configuration (public)",
+    metadata: { openApiTags: ["Config"], openApiSecurity: [] }
+  }
+});
+
+// src/v1/organisations.ts
+import { initContract as initContract8 } from "@ts-rest/core";
+import { z as z8 } from "zod";
+var c8 = initContract8();
+var SECURITY2 = [{ bearerAuth: [] }];
+var CreateOrganisationSchema = z8.object({
+  name: z8.string().min(1).max(255),
+  description: z8.string().optional(),
+  verifiablePresentation: z8.record(z8.unknown())
+});
+var UpdateOrganisationSchema = z8.object({
+  name: z8.string().min(1).max(255).optional(),
+  description: z8.string().nullable().optional(),
+  avatarUrl: z8.string().nullable().optional()
+});
+var OrgResponseSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  description: z8.string().nullable(),
+  avatarUrl: z8.string().nullable(),
+  didUri: z8.string().nullable(),
+  memberCount: z8.number(),
+  createdAt: z8.string(),
+  updatedAt: z8.string()
+});
+var OrgListItemSchema = OrgResponseSchema.extend({
+  role: z8.enum(["OWNER", "ADMIN", "ISSUER", "MEMBER"])
+});
+var OrgDetailResponseSchema = OrgListItemSchema.extend({
+  members: z8.array(z8.object({
+    id: z8.string(),
+    userId: z8.string(),
+    displayName: z8.string().nullable(),
+    role: z8.enum(["OWNER", "ADMIN", "ISSUER", "MEMBER"]),
+    joinedAt: z8.string()
+  }))
+});
+var MemberResponseSchema = z8.object({
+  id: z8.string(),
+  userId: z8.string(),
+  displayName: z8.string().nullable(),
+  role: z8.enum(["OWNER", "ADMIN", "ISSUER", "MEMBER"]),
+  joinedAt: z8.string()
+});
+var UpdateMemberRoleSchema = z8.object({
+  role: z8.enum(["ADMIN", "ISSUER", "MEMBER"])
+});
+var CreateInvitationSchema = z8.object({
+  expiresInDays: z8.number().int().positive().default(7).optional()
+});
+var InvitationResponseSchema = z8.object({
+  id: z8.string(),
+  orgId: z8.string(),
+  orgName: z8.string(),
+  token: z8.string(),
+  status: z8.enum(["PENDING", "SUBMITTED", "ACCEPTED", "DECLINED", "EXPIRED"]),
+  inviteeDisplayName: z8.string().nullable(),
+  createdAt: z8.string(),
+  expiresAt: z8.string()
+});
+var JoinInvitationSchema = z8.object({
+  verifiablePresentation: z8.record(z8.unknown())
+});
+var IssueVCSchema = z8.object({
+  holderDid: z8.string(),
+  credentialSubject: z8.record(z8.unknown()),
+  type: z8.array(z8.string()).optional()
+});
+var ErrorSchema = z8.object({ message: z8.string() });
+var VpRequestResponseSchema = z8.object({
+  vpRequest: z8.record(z8.unknown()),
+  expiresAt: z8.string()
+});
+var orgCrudContract = c8.router({
+  createVpRequest: {
+    method: "POST",
+    path: "/v1/organisations/vp-request",
+    body: z8.object({}),
+    responses: {
+      200: VpRequestResponseSchema,
+      401: ErrorSchema
+    },
+    summary: "Get VP request for creating an organisation",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  create: {
+    method: "POST",
+    path: "/v1/organisations",
+    body: CreateOrganisationSchema,
+    responses: {
+      201: OrgResponseSchema,
+      400: ErrorSchema,
+      401: ErrorSchema
+    },
+    summary: "Create a new organisation (requires CCCD VP)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  list: {
+    method: "GET",
+    path: "/v1/organisations",
+    responses: {
+      200: z8.array(OrgListItemSchema),
+      401: ErrorSchema
+    },
+    summary: "List user's organisations",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  getById: {
+    method: "GET",
+    path: "/v1/organisations/:orgId",
+    responses: {
+      200: OrgDetailResponseSchema,
+      401: ErrorSchema,
+      403: ErrorSchema,
+      404: ErrorSchema
+    },
+    summary: "Get organisation details (members only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  update: {
+    method: "PATCH",
+    path: "/v1/organisations/:orgId",
+    body: UpdateOrganisationSchema,
+    responses: {
+      200: OrgResponseSchema,
+      400: ErrorSchema,
+      401: ErrorSchema,
+      403: ErrorSchema,
+      404: ErrorSchema
+    },
+    summary: "Update organisation details (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  delete: {
+    method: "DELETE",
+    path: "/v1/organisations/:orgId",
+    body: c8.noBody(),
+    responses: {
+      204: z8.undefined(),
+      401: ErrorSchema,
+      403: ErrorSchema,
+      404: ErrorSchema
+    },
+    summary: "Delete organisation (owner only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  }
+});
+var orgMembersContract = c8.router({
+  listMembers: {
+    method: "GET",
+    path: "/v1/organisations/:orgId/members",
+    responses: {
+      200: z8.array(MemberResponseSchema),
+      401: ErrorSchema,
+      403: ErrorSchema
+    },
+    summary: "List organisation members",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  updateMemberRole: {
+    method: "PATCH",
+    path: "/v1/organisations/:orgId/members/:memberId",
+    body: UpdateMemberRoleSchema,
+    responses: {
+      200: MemberResponseSchema,
+      400: ErrorSchema,
+      401: ErrorSchema,
+      403: ErrorSchema,
+      404: ErrorSchema
+    },
+    summary: "Update member role (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  removeMember: {
+    method: "DELETE",
+    path: "/v1/organisations/:orgId/members/:memberId",
+    body: c8.noBody(),
+    responses: {
+      204: z8.undefined(),
+      400: ErrorSchema,
+      401: ErrorSchema,
+      403: ErrorSchema,
+      404: ErrorSchema
+    },
+    summary: "Remove member from organisation (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  }
+});
+var orgInvitationsContract = c8.router({
+  createInvitation: {
+    method: "POST",
+    path: "/v1/organisations/:orgId/invitations",
+    body: CreateInvitationSchema,
+    responses: {
+      201: InvitationResponseSchema,
+      401: ErrorSchema,
+      403: ErrorSchema
+    },
+    summary: "Create invitation (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  listInvitations: {
+    method: "GET",
+    path: "/v1/organisations/:orgId/invitations",
+    responses: {
+      200: z8.array(InvitationResponseSchema),
+      401: ErrorSchema,
+      403: ErrorSchema
+    },
+    summary: "List pending invitations (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  joinVpRequest: {
+    method: "POST",
+    path: "/v1/organisations/invitations/:token/vp-request",
+    body: z8.object({}),
+    responses: {
+      200: VpRequestResponseSchema,
+      401: ErrorSchema,
+      404: ErrorSchema,
+      410: ErrorSchema
+    },
+    summary: "Get VP request for joining via invitation",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  joinInvitation: {
+    method: "POST",
+    path: "/v1/organisations/invitations/:token/join",
+    body: JoinInvitationSchema,
+    responses: {
+      200: z8.object({ message: z8.string() }),
+      400: ErrorSchema,
+      401: ErrorSchema,
+      410: ErrorSchema
+    },
+    summary: "Invitee submits CCCD VP to join",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  acceptInvitation: {
+    method: "POST",
+    path: "/v1/organisations/:orgId/invitations/:invitationId/accept",
+    body: z8.object({}),
+    responses: {
+      200: z8.object({ message: z8.string(), memberId: z8.string() }),
+      401: ErrorSchema,
+      403: ErrorSchema,
+      409: ErrorSchema
+    },
+    summary: "Accept invitation (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  declineInvitation: {
+    method: "POST",
+    path: "/v1/organisations/:orgId/invitations/:invitationId/decline",
+    body: z8.object({}),
+    responses: {
+      200: z8.object({ message: z8.string() }),
+      401: ErrorSchema,
+      403: ErrorSchema,
+      409: ErrorSchema
+    },
+    summary: "Decline invitation (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  }
+});
+var orgCredentialsContract = c8.router({
+  issueVC: {
+    method: "POST",
+    path: "/v1/organisations/:orgId/credentials/issue",
+    body: IssueVCSchema,
+    responses: {
+      201: z8.record(z8.unknown()),
+      400: ErrorSchema,
+      401: ErrorSchema,
+      403: ErrorSchema
+    },
+    summary: "Issue VC on behalf of organisation (owner/admin/issuer)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  },
+  listIssuedCredentials: {
+    method: "GET",
+    path: "/v1/organisations/:orgId/credentials",
+    responses: {
+      200: z8.array(z8.object({
+        id: z8.string(),
+        holderDid: z8.string(),
+        issuingMemberId: z8.string(),
+        credentialJson: z8.record(z8.unknown()),
+        issuedAt: z8.string()
+      })),
+      401: ErrorSchema,
+      403: ErrorSchema
+    },
+    summary: "List issued credentials (owner/admin only)",
+    metadata: { openApiTags: ["Organisations"], openApiSecurity: SECURITY2 }
+  }
+});
+var organisationsContract = c8.router({
+  crud: orgCrudContract,
+  members: orgMembersContract,
+  invitations: orgInvitationsContract,
+  credentials: orgCredentialsContract
+});
+
+// src/index.ts
+var c9 = initContract9();
+var contract = c9.router({
+  v1: c9.router({
     auth: authContract,
     events: eventsContract,
     checkin: checkinContract,
-    turn: turnContract
+    turn: turnContract,
+    uploads: uploadsContract,
+    tracking: trackingContract,
+    config: appConfigContract,
+    organisations: organisationsContract
   })
 });
 export {
@@ -322,20 +743,43 @@ export {
   CheckinSubmitRequestSchema,
   CheckinSubmitResponseSchema,
   CreateEventSchema,
+  CreateInvitationSchema,
+  CreateOrganisationSchema,
   EventDetailResponseSchema,
+  EventDiscoverSchema,
   EventPublicInfoSchema,
   EventResponseSchema,
+  InvitationResponseSchema,
+  IssueVCSchema,
+  JoinInvitationSchema,
+  MemberResponseSchema,
+  OrgDetailResponseSchema,
+  OrgListItemSchema,
+  OrgResponseSchema,
   ParticipantSchema,
   SUPPORTED_FIELDS,
+  TrackScanRequestSchema,
+  TrackScanResponseSchema,
   TurnCredentialsResponseSchema,
   UpdateEventSchema,
+  UpdateMemberRoleSchema,
+  UpdateOrganisationSchema,
+  UploadPresignedUrlSchema,
   VerifyRequestSchema,
   VerifyResponseSchema,
+  appConfigContract,
   authContract,
   buildAuthMessage,
   checkinContract,
   contract,
   eventsContract,
-  turnContract
+  orgCredentialsContract,
+  orgCrudContract,
+  orgInvitationsContract,
+  orgMembersContract,
+  organisationsContract,
+  trackingContract,
+  turnContract,
+  uploadsContract
 };
 //# sourceMappingURL=index.mjs.map