@assemblis/contracts 0.0.1

package/src/schemas.ts

@@ -0,0 +1,348 @@
+import {
+	boolean,
+	coerce,
+	literal,
+	number,
+	object,
+	record,
+	string,
+	unknown,
+	undefined,
+	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() });
+
+export const UserSchema = {
+	payload: undefined(),
+	response: object({
+		id: string().uuid(),
+		created_at: coercedDate(),
+		updated_at: coercedDate(),
+		sub: string(),
+		is_mutirao: boolean()
+	})
+};
+
+// Surveys
+const SurveyQuestionSchema = object({
+	id: string().uuid(),
+	text: 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()
+	})
+};
+
+export const SurveyResponseSchema = {
+	payload: object({
+		answers: object({
+			question_id: string().uuid(),
+			answer_value: coerce.number().int()
+		}).array()
+	}),
+	response: object({
+		total: number().int()
+	})
+};
+
+// Action Plans
+const ActionPlanSchema = object({
+	visible_on_profile: boolean(),
+	description: maybe(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 TaskSchema = object({
+	text: string(),
+	complete: boolean().default(false),
+	action_id: string().uuid(),
+	assembly_id: 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)
+});
+export const AssemblyOverviewSchema = {
+	payload: BaseAssemblyOverviewSchema,
+	response: BaseAssemblyOverviewSchema.extend({
+		id: string().uuid(),
+		created_at: coercedDate(),
+		updated_at: coercedDate(),
+		has_image: boolean(),
+		image_src: maybe(string())
+	})
+};
+export const AssembliesListSchema = {
+	payload: undefined(),
+	response: object({
+		assemblies: AssemblyOverviewSchema.response.array()
+	})
+};
+
+// Assembly Details
+const OrganisationSchema = object({
+	visible_on_profile: boolean(),
+	name: maybe(string()),
+	description: maybe(string()),
+	type: maybe(string())
+});
+const EventDetailsSchema = object({
+	visible_on_profile: boolean(),
+	registration_link: maybe(string()),
+	start_date: maybe(coercedDate())
+});
+const StorySchema = object({
+	visible_on_profile: boolean(),
+	background: maybe(string())
+});
+const SupportersSchema = object({
+	visible_on_profile: boolean(),
+	organisation_types: string().array(),
+	description: maybe(string())
+});
+const FundersSchema = object({
+	visible_on_profile: boolean(),
+	organisation_types: string().array(),
+	description: maybe(string())
+});
+const FacilitationSchema = object({
+	visible_on_profile: boolean(),
+	decision_method: maybe(string())
+});
+const ParticipantsSchema = object({
+	visible_on_profile: boolean(),
+	recruitment_method: maybe(string()),
+	community: maybe(string())
+});
+const SupportSchema = object({
+	visible_on_profile: boolean(),
+	support_options: string().array()
+});
+const SurveyDetailsSchema = object({
+	visible_on_profile: boolean()
+});
+export const AssemblyDetailSchema = {
+	payload: AssemblyOverviewSchema.payload.extend({
+		organisation: maybe(
+			OrganisationSchema.extend({
+				id: string().uuid().optional()
+			})
+		),
+		event_details: maybe(EventDetailsSchema),
+		story: maybe(StorySchema),
+		supporters: maybe(SupportersSchema),
+		funders: maybe(FundersSchema),
+		facilitation: maybe(FacilitationSchema),
+		participants: maybe(ParticipantsSchema),
+		support: maybe(SupportSchema),
+		action_plan: maybe(
+			ActionPlanSchema.extend({
+				actions: ActionSchema.omit({ assembly_id: true })
+					.extend({
+						id: string().uuid().optional(),
+						tasks: TaskSchema.omit({
+							action_id: true,
+							assembly_id: true
+						})
+							.extend({
+								id: string().uuid().optional()
+							})
+							.array(),
+						updates: unknown().array()
+					})
+					.array(),
+				updates: unknown().array()
+			})
+		),
+		surveys: maybe(SurveyDetailsSchema)
+	}),
+	response: AssemblyOverviewSchema.response.extend({
+		is_own: boolean(),
+		organisation: maybe(
+			OrganisationSchema.extend({
+				id: string().uuid(),
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		event_details: maybe(
+			EventDetailsSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		story: maybe(
+			StorySchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		supporters: maybe(
+			SupportersSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		funders: maybe(
+			FundersSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		facilitation: maybe(
+			FacilitationSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		participants: maybe(
+			ParticipantsSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		support: maybe(
+			SupportSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			})
+		),
+		action_plan: maybe(
+			ActionPlanSchema.extend({
+				actions: ActionSchema.omit({ assembly_id: true })
+					.extend({
+						id: string().uuid(),
+						created_at: coercedDate(),
+						updated_at: coercedDate(),
+						tasks: TaskSchema.omit({
+							action_id: true,
+							assembly_id: true
+						})
+							.extend({
+								id: string().uuid(),
+								created_at: coercedDate(),
+								updated_at: coercedDate()
+							})
+							.array(),
+						updates: unknown().array()
+					})
+					.extend({
+						created_at: coercedDate(),
+						updated_at: coercedDate()
+					})
+					.array(),
+				updates: unknown().array()
+			}).and(
+				object({
+					created_at: coercedDate(),
+					updated_at: coercedDate()
+				})
+			)
+		),
+		surveys: maybe(
+			SurveyDetailsSchema.extend({
+				created_at: coercedDate(),
+				updated_at: coercedDate()
+			}).extend({
+				data: record(
+					string(),
+					object({
+						total: number().int(),
+						responses: record(string(), OptionSchema.array())
+					})
+				)
+			})
+		)
+	})
+};
+
+export const FeedbackSchema = {
+	payload: object({
+		route: string(),
+		text: string(),
+		metadata: unknown()
+	}),
+	response: string()
+};
+
+export const LogSchema = {
+	payload: object({
+		message: string().optional(),
+		data: record(string(), string().optional()).optional(),
+		metadata: object({
+			origin: string(),
+			route: string(),
+			status: number()
+		})
+	}),
+	response: string()
+};
+
+export const RegisterSchema = {
+	payload: object({
+		type: literal('user.created'),
+		object: literal('event'),
+		data: object({
+			id: string(),
+			email_addresses: object({
+				email_address: string()
+			}).array()
+		})
+	}),
+	response: string()
+};
+
+export const PinSchema = {
+	payload: object({
+		country: string(),
+		email: string(),
+		text: maybe(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())
+	})
+};
+export const PinListSchema = {
+	payload: undefined(),
+	response: object({
+		assemblies: AssemblyOverviewSchema.response.array(),
+		pins: PinSchema.response.array()
+	})
+};

package/src/types.ts

@@ -0,0 +1,77 @@
+import z from 'zod';
+import {
+	AssembliesListSchema,
+	AssemblyDetailSchema,
+	AssemblyOverviewSchema,
+	FeedbackSchema,
+	LogSchema,
+	PinListSchema,
+	PinSchema,
+	RegisterSchema,
+	SurveyResponseSchema,
+	SurveySchema,
+	UserSchema
+} from './schemas';
+
+export enum Method {
+	GET = 'GET',
+	POST = 'POST',
+	PUT = 'PUT',
+	PATCH = 'PATCH'
+}
+
+export enum RouteParameters {
+	ID = ':ID',
+	NAME = ':NAME'
+}
+
+export enum Endpoint {
+	ASSEMBLIES = '/assemblies',
+	FEEDBACK = '/feedback',
+	INTEREST_ASSEMBLIS = '/interest/assemblis',
+	INTEREST_MUTIRAO = '/interest/mutirao',
+	LOGS = '/logs',
+	PINS = '/pins',
+	SURVEYS = '/surveys',
+	SURVEY_RESPONSES = '/assemblies/:ID/survey-responses/:NAME'
+}
+
+export type AssemblyDetailPayload = z.infer<
+	(typeof AssemblyDetailSchema)['payload']
+>;
+export type AssemblyOverviewPayload = z.infer<
+	(typeof AssemblyOverviewSchema)['payload']
+>;
+export type AssembliesListPayload = z.infer<
+	(typeof AssembliesListSchema)['payload']
+>;
+export type FeedbackPayload = z.infer<(typeof FeedbackSchema)['payload']>;
+export type LogPayload = z.infer<(typeof LogSchema)['payload']>;
+export type PinPayload = z.infer<(typeof PinSchema)['payload']>;
+export type PinListPayload = z.infer<(typeof PinListSchema)['payload']>;
+export type RegisterPayload = z.infer<(typeof RegisterSchema)['payload']>;
+export type SurveyPayload = z.infer<(typeof SurveySchema)['payload']>;
+export type SurveyResponsePayload = z.infer<
+	(typeof SurveyResponseSchema)['payload']
+>;
+export type UserPayload = z.infer<(typeof UserSchema)['payload']>;
+
+export type AssemblyDetailResponse = z.infer<
+	(typeof AssemblyDetailSchema)['response']
+>;
+export type AssemblyOverviewResponse = z.infer<
+	(typeof AssemblyOverviewSchema)['response']
+>;
+export type AssembliesListResponse = z.infer<
+	(typeof AssembliesListSchema)['response']
+>;
+export type FeedbackResponse = z.infer<(typeof FeedbackSchema)['response']>;
+export type LogResponse = z.infer<(typeof LogSchema)['response']>;
+export type PinResponse = z.infer<(typeof PinSchema)['response']>;
+export type PinListResponse = z.infer<(typeof PinListSchema)['response']>;
+export type RegisterResponse = z.infer<(typeof RegisterSchema)['response']>;
+export type SurveyResponse = z.infer<(typeof SurveySchema)['response']>;
+export type SurveyResponseResponse = z.infer<
+	(typeof SurveyResponseSchema)['response']
+>;
+export type UserResponse = z.infer<(typeof UserSchema)['response']>;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"lib": ["DOM", "ES2023"],
+		"skipLibCheck": true,
+		"strict": true,
+		"declaration": true,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"baseUrl": ".",
+		"outDir": "dist"
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", "dist"]
+}