@assemblis/contracts 0.0.10 → 0.0.11

package/dist/types.d.ts

@@ -1,16 +1,16 @@
 import z from 'zod';
 import { AssembliesListSchema, AssemblyDetailSchema, AssemblyOverviewSchema, FeedbackSchema, LogSchema, PinListSchema, PinSchema, RegisterSchema, SurveyResponseSchema, SurveySchema, UserSchema } from './schemas';
-export declare enum Method {
+export declare enum ApiRestMethod {
     GET = "GET",
     POST = "POST",
     PUT = "PUT",
     PATCH = "PATCH"
 }
-export declare enum RouteParameters {
+export declare enum ApiRouteParameter {
     ID = ":ID",
     NAME = ":NAME"
 }
-export declare enum Endpoint {
+export declare enum ApiEndpoint {
     ASSEMBLIES = "/assemblies",
     FEEDBACK = "/feedback",
     INTEREST_ASSEMBLIS = "/interest/assemblis",
@@ -20,6 +20,12 @@ export declare enum Endpoint {
     SURVEYS = "/surveys",
     SURVEY_RESPONSES = "/assemblies/:ID/survey-responses/:NAME"
 }
+export declare enum SurveyName {
+    DELIBERATION = "deliberation",
+    DEMOGRAPHIC_DATA = "demographic-data",
+    PRE_ASSEMBLY = "pre-assembly",
+    POST_ASSEMBLY = "post-assembly"
+}
 export type AssemblyDetailPayload = z.infer<(typeof AssemblyDetailSchema)['payload']>;
 export type AssemblyOverviewPayload = z.infer<(typeof AssemblyOverviewSchema)['payload']>;
 export type AssembliesListPayload = z.infer<(typeof AssembliesListSchema)['payload']>;

package/package.json

@@ -1,21 +1,24 @@
 {
 	"name": "@assemblis/contracts",
-	"version": "0.0.10",
+	"version": "0.0.11",
 	"private": false,
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"devDependencies": {
 		"@rollup/plugin-terser": "^0.4.4",
-		"@rollup/plugin-typescript": "^11.1.6",
-		"rollup": "^4.20.0",
-		"typescript": "^5.5.0"
+		"@rollup/plugin-typescript": "^12.3.0",
+		"rollup": "^4.57.1",
+		"typescript": "^5.9.3"
 	},
 	"dependencies": {
-		"zod": "^3.25.42"
+		"zod": "^4.3.6"
 	},
 	"scripts": {
 		"build": "rollup --config rollup.config.ts --configPlugin typescript -o 'dist/index.js' src/index.ts",
-		"clean": "rm -rf ./dist"
+		"clean": "rm -rf ./dist",
+		"lint": "eslint .",
+		"format": "prettier --plugin-search-dir . --write .",
+		"typecheck": "tsc --noEmit"
 	}
 }

package/src/schemas.ts

@@ -1,161 +1,154 @@
-import {
-	boolean,
-	coerce,
-	literal,
-	number,
-	object,
-	record,
-	string,
-	unknown,
-	undefined,
-	type ZodType
-} from 'zod';
+import z, {type ZodType} from "zod";
 
-const coercedDate = coerce.date;
 const maybe = <T extends ZodType<unknown>>(_: T) =>
 	_.nullish().transform((_) => _ ?? null);
 
-const OptionSchema = object({ label: string(), value: coerce.number().int() });
+const OptionSchema = z.object({
+	label: z.string(),
+	value: z.coerce.number().int()
+});
 
 export const UserSchema = {
-	payload: undefined(),
-	response: object({
-		id: string().uuid(),
-		created_at: coercedDate(),
-		updated_at: coercedDate(),
-		sub: string(),
-		is_mutirao: boolean()
+	payload: z.undefined(),
+	response: z.object({
+		id: z.string().uuid(),
+		created_at: z.coerce.date(),
+		updated_at: z.coerce.date(),
+		sub: z.string(),
+		is_mutirao: z.boolean()
 	})
 };
 
 // Surveys
-const SurveyQuestionSchema = object({
-	id: string().uuid(),
-	text: string()
+const SurveyQuestionSchema = z.object({
+	id: z.string().uuid(),
+	text: z.string()
 });
 
 export const SurveySchema = {
-	payload: undefined(),
-	response: object({
-		id: string().uuid(),
-		created_at: coercedDate(),
-		updated_at: coercedDate(),
-		name: string(),
-		sections: object({
-			primary: SurveyQuestionSchema,
-			secondary: SurveyQuestionSchema.array(),
-			options: OptionSchema.array()
-		}).array()
+	payload: z.undefined(),
+	response: z.object({
+		id: z.string().uuid(),
+		created_at: z.coerce.date(),
+		updated_at: z.coerce.date(),
+		name: z.string(),
+		sections: z.object({
+				primary: SurveyQuestionSchema,
+				secondary: SurveyQuestionSchema.array(),
+				options: OptionSchema.array()
+			})
+			.array()
 	})
 };
 
 export const SurveyResponseSchema = {
-	payload: object({
-		answers: object({
-			question_id: string().uuid(),
-			answer_value: coerce.number().int()
-		}).array()
+	payload: z.object({
+		answers: z.object({
+				question_id: z.string().uuid(),
+				answer_value: z.coerce.number().int()
+			})
+			.array()
 	}),
-	response: object({
-		total: number().int()
+	response: z.object({
+		total: z.number().int()
 	})
 };
 
 // Action Plans
-const ActionPlanSchema = object({
-	visible_on_profile: boolean(),
-	description: maybe(string())
+const ActionPlanSchema = z.object({
+	visible_on_profile: z.boolean(),
+	description: maybe(z.string())
 });
 
-const ActionSchema = object({
-	text: string(),
-	agreed: maybe(coerce.number().int()),
-	against: maybe(coerce.number().int()),
-	abstained: maybe(coerce.number().int()),
-	include_in_action_plan: boolean().default(true),
-	assembly_id: string().uuid()
+const ActionSchema = z.object({
+	text: z.string(),
+	agreed: maybe(z.coerce.number().int()),
+	against: maybe(z.coerce.number().int()),
+	abstained: maybe(z.coerce.number().int()),
+	include_in_action_plan: z.boolean().default(true),
+	assembly_id: z.string().uuid()
 });
 
-const TaskSchema = object({
-	text: string(),
-	complete: boolean().default(false),
-	action_id: string().uuid(),
-	assembly_id: string().uuid()
+const TaskSchema = z.object({
+	text: z.string(),
+	complete: z.boolean().default(false),
+	action_id: z.string().uuid(),
+	assembly_id: z.string().uuid()
 });
 
 // Assembly Overviews
-const BaseAssemblyOverviewSchema = object({
-	published_at: maybe(coercedDate()),
-	name: string(),
-	about: maybe(string()),
-	topics: string().array(),
-	country: maybe(string()),
-	hide: boolean().default(false)
+const BaseAssemblyOverviewSchema = z.object({
+	published_at: maybe(z.coerce.date()),
+	name: z.string(),
+	about: maybe(z.string()),
+	topics: z.string().array(),
+	country: maybe(z.string()),
+	hide: z.boolean().default(false)
 });
 export const AssemblyOverviewSchema = {
 	payload: BaseAssemblyOverviewSchema,
 	response: BaseAssemblyOverviewSchema.extend({
-		id: string().uuid(),
-		created_at: coercedDate(),
-		updated_at: coercedDate(),
-		has_image: boolean(),
-		image_src: maybe(string())
+		id: z.string().uuid(),
+		created_at: z.coerce.date(),
+		updated_at: z.coerce.date(),
+		has_image: z.boolean(),
+		image_src: maybe(z.string())
 	})
 };
 export const AssembliesListSchema = {
-	payload: undefined(),
-	response: object({
+	payload: z.undefined(),
+	response: z.object({
 		assemblies: AssemblyOverviewSchema.response.array()
 	})
 };
 
 // Assembly Details
-const OrganisationSchema = object({
-	visible_on_profile: boolean(),
-	name: maybe(string()),
-	description: maybe(string()),
-	type: maybe(string())
+const OrganisationSchema = z.object({
+	visible_on_profile: z.boolean(),
+	name: maybe(z.string()),
+	description: maybe(z.string()),
+	type: maybe(z.string())
 });
-const EventDetailsSchema = object({
-	visible_on_profile: boolean(),
-	registration_link: maybe(string()),
-	start_date: maybe(coercedDate())
+const EventDetailsSchema = z.object({
+	visible_on_profile: z.boolean(),
+	registration_link: maybe(z.string()),
+	start_date: maybe(z.coerce.date())
 });
-const StorySchema = object({
-	visible_on_profile: boolean(),
-	background: maybe(string())
+const StorySchema = z.object({
+	visible_on_profile: z.boolean(),
+	background: maybe(z.string())
 });
-const SupportersSchema = object({
-	visible_on_profile: boolean(),
-	organisation_types: string().array(),
-	description: maybe(string())
+const SupportersSchema = z.object({
+	visible_on_profile: z.boolean(),
+	organisation_types: z.string().array(),
+	description: maybe(z.string())
 });
-const FundersSchema = object({
-	visible_on_profile: boolean(),
-	organisation_types: string().array(),
-	description: maybe(string())
+const FundersSchema = z.object({
+	visible_on_profile: z.boolean(),
+	organisation_types: z.string().array(),
+	description: maybe(z.string())
 });
-const FacilitationSchema = object({
-	visible_on_profile: boolean(),
-	decision_method: maybe(string())
+const FacilitationSchema = z.object({
+	visible_on_profile: z.boolean(),
+	decision_method: maybe(z.string())
 });
-const ParticipantsSchema = object({
-	visible_on_profile: boolean(),
-	recruitment_method: maybe(string()),
-	community: maybe(string())
+const ParticipantsSchema = z.object({
+	visible_on_profile: z.boolean(),
+	recruitment_method: maybe(z.string()),
+	community: maybe(z.string())
 });
-const SupportSchema = object({
-	visible_on_profile: boolean(),
-	support_options: string().array()
+const SupportSchema = z.object({
+	visible_on_profile: z.boolean(),
+	support_options: z.string().array()
 });
-const SurveyDetailsSchema = object({
-	visible_on_profile: boolean()
+const SurveyDetailsSchema = z.object({
+	visible_on_profile: z.boolean()
 });
 export const AssemblyDetailSchema = {
 	payload: AssemblyOverviewSchema.payload.extend({
 		organisation: maybe(
 			OrganisationSchema.extend({
-				id: string().uuid().optional()
+				id: z.string().uuid().optional()
 			})
 		),
 		event_details: maybe(EventDetailsSchema),
@@ -169,116 +162,116 @@ export const AssemblyDetailSchema = {
 			ActionPlanSchema.extend({
 				actions: ActionSchema.omit({ assembly_id: true })
 					.extend({
-						id: string().uuid().optional(),
+						id: z.string().uuid().optional(),
 						tasks: TaskSchema.omit({
 							action_id: true,
 							assembly_id: true
 						})
 							.extend({
-								id: string().uuid().optional()
+								id: z.string().uuid().optional()
 							})
 							.array(),
-						updates: unknown().array()
+						updates: z.unknown().array()
 					})
 					.array(),
-				updates: unknown().array()
+				updates: z.unknown().array()
 			})
 		),
 		surveys: maybe(SurveyDetailsSchema)
 	}),
 	response: AssemblyOverviewSchema.response.extend({
-		is_own: boolean(),
+		is_own: z.boolean(),
 		organisation: maybe(
 			OrganisationSchema.extend({
-				id: string().uuid(),
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				id: z.string().uuid(),
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		event_details: maybe(
 			EventDetailsSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		story: maybe(
 			StorySchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		supporters: maybe(
 			SupportersSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		funders: maybe(
 			FundersSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		facilitation: maybe(
 			FacilitationSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		participants: maybe(
 			ParticipantsSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		support: maybe(
 			SupportSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			})
 		),
 		action_plan: maybe(
 			ActionPlanSchema.extend({
 				actions: ActionSchema.omit({ assembly_id: true })
 					.extend({
-						id: string().uuid(),
-						created_at: coercedDate(),
-						updated_at: coercedDate(),
+						id: z.string().uuid(),
+						created_at: z.coerce.date(),
+						updated_at: z.coerce.date(),
 						tasks: TaskSchema.omit({
 							action_id: true,
 							assembly_id: true
 						})
 							.extend({
-								id: string().uuid(),
-								created_at: coercedDate(),
-								updated_at: coercedDate()
+								id: z.string().uuid(),
+								created_at: z.coerce.date(),
+								updated_at: z.coerce.date()
 							})
 							.array(),
-						updates: unknown().array()
+						updates: z.unknown().array()
 					})
 					.extend({
-						created_at: coercedDate(),
-						updated_at: coercedDate()
+						created_at: z.coerce.date(),
+						updated_at: z.coerce.date()
 					})
 					.array(),
-				updates: unknown().array()
+				updates: z.unknown().array()
 			}).and(
-				object({
-					created_at: coercedDate(),
-					updated_at: coercedDate()
+				z.object({
+					created_at: z.coerce.date(),
+					updated_at: z.coerce.date()
 				})
 			)
 		),
 		surveys: maybe(
 			SurveyDetailsSchema.extend({
-				created_at: coercedDate(),
-				updated_at: coercedDate()
+				created_at: z.coerce.date(),
+				updated_at: z.coerce.date()
 			}).extend({
-				data: record(
-					string(),
-					object({
-						total: number().int(),
-						responses: record(string(), OptionSchema.array())
+				data: z.record(
+					z.string(),
+					z.object({
+						total: z.number().int(),
+						responses: z.record(z.string(), OptionSchema.array())
 					})
 				)
 			})
@@ -287,61 +280,62 @@ export const AssemblyDetailSchema = {
 };
 
 export const FeedbackSchema = {
-	payload: object({
-		route: string(),
-		text: string(),
-		metadata: unknown()
+	payload: z.object({
+		route: z.string(),
+		text: z.string(),
+		metadata: z.unknown()
 	}),
-	response: string()
+	response: z.string()
 };
 
 export const LogSchema = {
-	payload: object({
-		message: string().optional(),
-		data: record(string(), string().optional()).optional(),
-		metadata: object({
-			origin: string(),
-			route: string(),
-			status: number()
+	payload: z.object({
+		message: z.string().optional(),
+		data: z.record(z.string(), z.string().optional()).optional(),
+		metadata: z.object({
+			origin: z.string(),
+			route: z.string(),
+			status: z.number()
 		})
 	}),
-	response: string()
+	response: z.string()
 };
 
 export const RegisterSchema = {
-	payload: object({
-		type: literal('user.created'),
-		object: literal('event'),
-		data: object({
-			id: string(),
-			email_addresses: object({
-				email_address: string()
-			}).array()
+	payload: z.object({
+		type: z.literal('user.created'),
+		object: z.literal('event'),
+		data: z.object({
+			id: z.string(),
+			email_addresses: z.object({
+					email_address: z.string()
+				})
+				.array()
 		})
 	}),
-	response: string()
+	response: z.string()
 };
 
 export const PinSchema = {
-	payload: object({
-		country: string(),
-		email: string(),
-		text: maybe(string())
+	payload: z.object({
+		country: z.string(),
+		email: z.string(),
+		text: maybe(z.string())
 	}),
-	response: object({
-		id: string().uuid(),
-		created_at: coercedDate(),
-		updated_at: coercedDate(),
-		country: string(),
-		text: maybe(string()),
-		hide: boolean(),
-		has_image: boolean(),
-		image_src: maybe(string())
+	response: z.object({
+		id: z.string().uuid(),
+		created_at: z.coerce.date(),
+		updated_at: z.coerce.date(),
+		country: z.string(),
+		text: maybe(z.string()),
+		hide: z.boolean(),
+		has_image: z.boolean(),
+		image_src: maybe(z.string())
 	})
 };
 export const PinListSchema = {
-	payload: undefined(),
-	response: object({
+	payload: z.undefined(),
+	response: z.object({
 		assemblies: AssemblyOverviewSchema.response.array(),
 		pins: PinSchema.response.array()
 	})

package/src/types.ts

@@ -13,19 +13,19 @@ import {
 	UserSchema
 } from './schemas';
 
-export enum Method {
+export enum ApiRestMethod {
 	GET = 'GET',
 	POST = 'POST',
 	PUT = 'PUT',
 	PATCH = 'PATCH'
 }
 
-export enum RouteParameters {
+export enum ApiRouteParameter {
 	ID = ':ID',
 	NAME = ':NAME'
 }
 
-export enum Endpoint {
+export enum ApiEndpoint {
 	ASSEMBLIES = '/assemblies',
 	FEEDBACK = '/feedback',
 	INTEREST_ASSEMBLIS = '/interest/assemblis',
@@ -36,6 +36,13 @@ export enum Endpoint {
 	SURVEY_RESPONSES = '/assemblies/:ID/survey-responses/:NAME'
 }
 
+export enum SurveyName {
+	DELIBERATION = 'deliberation',
+	DEMOGRAPHIC_DATA = 'demographic-data',
+	PRE_ASSEMBLY = 'pre-assembly',
+	POST_ASSEMBLY = 'post-assembly'
+}
+
 export type AssemblyDetailPayload = z.infer<
 	(typeof AssemblyDetailSchema)['payload']
 >;

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
 	"compilerOptions": {
 		"importHelpers": true,
-    "moduleResolution": "node",
+		"moduleResolution": "node",
 		"module": "ES2022",
 		"target": "ES2021",
 		"strictNullChecks": true,