tonightpass 0.0.108 → 0.0.110

package/src/rest/dtos/locations/create-location.dto.ts

@@ -0,0 +1,68 @@
+import { Type } from "class-transformer";
+import {
+  IsArray,
+  IsNotEmpty,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Length,
+  ValidateNested,
+} from "class-validator";
+
+import { GeoPoint, Location } from "../../types";
+
+export class GeoPointDto implements GeoPoint {
+  @IsString()
+  @IsNotEmpty()
+  type: "Point";
+
+  @IsArray()
+  @IsNotEmpty()
+  @Length(2, 2)
+  @IsNumber({}, { each: true })
+  coordinates: [number, number];
+
+  constructor() {
+    this.type = "Point";
+  }
+
+  @ValidateNested()
+  public validate(): boolean {
+    const [longitude, latitude] = this.coordinates;
+    return (
+      latitude >= -90 && latitude <= 90 && longitude >= -180 && longitude <= 180
+    );
+  }
+}
+
+export class CreateLocationDto implements Location {
+  @IsOptional()
+  @IsString()
+  @Length(1, 128)
+  name?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 256)
+  address: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 32)
+  zipCode: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 128)
+  city: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Length(1, 128)
+  country: string;
+
+  @ValidateNested()
+  @Type(() => GeoPointDto)
+  @IsNotEmpty()
+  geometry: GeoPointDto;
+}

package/src/rest/dtos/locations/index.ts

@@ -0,0 +1,2 @@
+export * from "./create-location.dto";
+export * from "./update-location.dto";

package/src/rest/dtos/locations/update-location.dto.ts

@@ -0,0 +1,37 @@
+import { Type } from "class-transformer";
+import { IsOptional, IsString, Length, ValidateNested } from "class-validator";
+
+import { GeoPointDto } from "./create-location.dto";
+import { Location } from "../../types";
+
+export class UpdateLocationDto implements Partial<Location> {
+  @IsOptional()
+  @IsString()
+  @Length(1, 128)
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  @Length(1, 256)
+  address?: string;
+
+  @IsOptional()
+  @IsString()
+  @Length(1, 32)
+  zipCode?: string;
+
+  @IsOptional()
+  @IsString()
+  @Length(1, 128)
+  city?: string;
+
+  @IsOptional()
+  @IsString()
+  @Length(1, 128)
+  country?: string;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => GeoPointDto)
+  geometry?: GeoPointDto;
+}

package/src/rest/dtos/organizations/events/create-organization-event.dto.ts

@@ -1,23 +1,46 @@
+import { Type } from "class-transformer";
 import {
+  IsArray,
   IsDateString,
   IsEnum,
   IsLowercase,
+  IsNotEmpty,
+  IsObject,
   IsOptional,
   IsString,
+  IsUrl,
   Length,
   Matches,
+  ValidateNested,
 } from "class-validator";
 
-import { CreateOrganizationEventTicketDto } from "./tickets";
+import {
+  CreateOrganizationEventTicketDto,
+  CreateOrganizationEventTicketInput,
+} from "./tickets";
 import { REGEX } from "../../../../constants";
 import {
-  Location,
   OrganizationEventType,
   OrganizationEventVisibilityType,
+  OrganizationEvent,
+  ExcludeBase,
 } from "../../../types";
+import { CreateLocationDto } from "../../locations/create-location.dto";
 
-export class CreateOrganizationEventDto {
+export type CreateOrganizationEventInput = Omit<
+  ExcludeBase<OrganizationEvent>,
+  "slug" | "styles" | "tickets" | "organization"
+> & {
+  slug?: string;
+  styles: string[];
+  tickets: CreateOrganizationEventTicketInput[];
+};
+
+export class CreateOrganizationEventDto
+  implements CreateOrganizationEventInput
+{
   @IsString()
+  @IsNotEmpty()
   @Length(1, 64)
   title: string;
 
@@ -29,24 +52,48 @@ export class CreateOrganizationEventDto {
   slug?: string;
 
   @IsString()
+  @IsNotEmpty()
   @Length(16, 2048)
   description: string;
 
   @IsEnum(OrganizationEventType)
+  @IsNotEmpty()
   type: OrganizationEventType;
 
   @IsEnum(OrganizationEventVisibilityType)
+  @IsNotEmpty()
   visibility: OrganizationEventVisibilityType;
 
+  @IsArray()
+  @IsUrl({}, { each: true })
   flyers: string[];
+
+  @IsArray()
+  @IsUrl({}, { each: true })
   trailers: string[];
-  location: Location;
+
+  @IsObject()
+  @ValidateNested()
+  @Type(() => CreateLocationDto)
+  @IsNotEmpty()
+  location: CreateLocationDto;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => CreateOrganizationEventTicketDto)
+  @IsNotEmpty()
   tickets: CreateOrganizationEventTicketDto[];
-  styles: string[];
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsNotEmpty()
+  styles: string[]; // Array of style IDs
 
   @IsDateString()
+  @IsNotEmpty()
   startAt: Date;
 
   @IsDateString()
+  @IsNotEmpty()
   endAt: Date;
 }

package/src/rest/dtos/organizations/events/tickets/create-organization-event-ticket.dto.ts

@@ -13,9 +13,20 @@ import {
   Currency,
   OrganizationEventTicketCategory,
   OrganizationEventTicketType,
+  OrganizationEventTicket,
+  ExcludeBase,
 } from "../../../../types";
 
-export class CreateOrganizationEventTicketDto {
+export type CreateOrganizationEventTicketInput = Omit<
+  ExcludeBase<OrganizationEventTicket>,
+  "price" | "product" | "event" | "fee"
+> & {
+  price: number;
+};
+
+export class CreateOrganizationEventTicketDto
+  implements CreateOrganizationEventTicketInput
+{
   @IsString()
   @Length(1, 128)
   name: string;

package/src/rest/dtos/organizations/events/tickets/update-organization-event-ticket.dto.ts

@@ -1,3 +1,70 @@
-import { CreateOrganizationEventTicketDto } from "./create-organization-event-ticket.dto";
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Length,
+  Min,
+} from "class-validator";
 
-export class UpdateOrganizationEventTicketDto extends CreateOrganizationEventTicketDto {}
+import { CreateOrganizationEventTicketInput } from "./create-organization-event-ticket.dto";
+import {
+  Currency,
+  DeepPartial,
+  OrganizationEventTicketCategory,
+  OrganizationEventTicketType,
+} from "../../../../types";
+
+export class UpdateOrganizationEventTicketDto
+  implements DeepPartial<CreateOrganizationEventTicketInput>
+{
+  @IsString()
+  @Length(1, 128)
+  @IsOptional()
+  name?: string;
+
+  @IsString()
+  @Length(1, 1024)
+  @IsOptional()
+  description?: string;
+
+  @IsNumber()
+  @Min(0)
+  @IsOptional()
+  price?: number;
+
+  @IsNumber()
+  @Min(0)
+  @IsOptional()
+  quantity?: number;
+
+  @IsEnum(OrganizationEventTicketType)
+  @IsOptional()
+  type?: OrganizationEventTicketType;
+
+  @IsEnum(OrganizationEventTicketCategory)
+  @IsOptional()
+  category?: OrganizationEventTicketCategory;
+
+  @IsEnum(Currency)
+  @IsOptional()
+  currency?: Currency;
+
+  @IsBoolean()
+  @IsOptional()
+  isVisible?: boolean;
+
+  @IsBoolean()
+  @IsOptional()
+  isFeesIncluded?: boolean;
+
+  @IsDateString()
+  @IsOptional()
+  startAt?: Date;
+
+  @IsDateString()
+  @IsOptional()
+  endAt?: Date;
+}

package/src/rest/dtos/organizations/events/update-organization-event.dto.ts

@@ -1,3 +1,88 @@
-import { CreateOrganizationEventDto } from "./create-organization-event.dto";
+import { Type } from "class-transformer";
+import {
+  IsArray,
+  IsDateString,
+  IsEnum,
+  IsLowercase,
+  IsObject,
+  IsOptional,
+  IsString,
+  IsUrl,
+  Length,
+  Matches,
+  ValidateNested,
+} from "class-validator";
 
-export class UpdateOrganizationEventDto extends CreateOrganizationEventDto {}
+import { CreateOrganizationEventInput } from "./create-organization-event.dto";
+import { UpdateOrganizationEventTicketDto } from "./tickets";
+import { REGEX } from "../../../../constants";
+import {
+  DeepPartial,
+  OrganizationEventType,
+  OrganizationEventVisibilityType,
+} from "../../../types";
+import { UpdateLocationDto } from "../../locations/update-location.dto";
+
+export class UpdateOrganizationEventDto
+  implements DeepPartial<CreateOrganizationEventInput>
+{
+  @IsOptional()
+  @IsString()
+  @Length(1, 64)
+  title?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsLowercase()
+  @Length(3, 48)
+  @Matches(REGEX.SLUG)
+  slug?: string;
+
+  @IsOptional()
+  @IsString()
+  @Length(16, 2048)
+  description?: string;
+
+  @IsOptional()
+  @IsEnum(OrganizationEventType)
+  type?: OrganizationEventType;
+
+  @IsOptional()
+  @IsEnum(OrganizationEventVisibilityType)
+  visibility?: OrganizationEventVisibilityType;
+
+  @IsOptional()
+  @IsArray()
+  @IsUrl({}, { each: true })
+  flyers?: string[];
+
+  @IsOptional()
+  @IsArray()
+  @IsUrl({}, { each: true })
+  trailers?: string[];
+
+  @IsOptional()
+  @IsObject()
+  @ValidateNested()
+  @Type(() => UpdateLocationDto)
+  location?: UpdateLocationDto;
+
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => UpdateOrganizationEventTicketDto)
+  tickets?: UpdateOrganizationEventTicketDto[];
+
+  @IsOptional()
+  @IsArray()
+  @IsString({ each: true })
+  styles?: string[];
+
+  @IsOptional()
+  @IsDateString()
+  startAt?: Date;
+
+  @IsOptional()
+  @IsDateString()
+  endAt?: Date;
+}

package/src/rest/dtos/users/create-user.dto.ts

@@ -1,3 +1,4 @@
+import { Type } from "class-transformer";
 import {
   IsDateString,
   IsEmail,
@@ -9,14 +10,19 @@ import {
   IsUrl,
   Length,
   Matches,
+  ValidateNested,
 } from "class-validator";
 
 import { REGEX } from "../../../constants";
 import { UserIdentifier, UserIdentityGender } from "../../types";
 
 export class CreateUserDto {
+  @ValidateNested()
+  @Type(() => CreateUserIdentifierDto)
   identifier: CreateUserIdentifierDto;
 
+  @ValidateNested()
+  @Type(() => CreateUserIdentityDto)
   identity: CreateUserIdentityDto;
 
   @IsString()

package/src/rest/dtos/users/sign-in-user.dto.ts

@@ -1,4 +1,11 @@
+import { IsNotEmpty, IsString } from "class-validator";
+
 export class SignInUserDto {
+  @IsNotEmpty()
+  @IsString()
   identifier: string;
+
+  @IsNotEmpty()
+  @IsString()
   password: string;
 }

package/src/rest/types/index.ts

@@ -17,6 +17,10 @@ export type Base = {
 
 export type ExcludeBase<T> = Omit<T, keyof Base>;
 
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
 // Currency
 export enum Currency {
   EUR = "EUR",

package/src/rest/types/locations/index.ts

@@ -1,3 +1,11 @@
+/**
+ * Represents a GeoJSON point with specific geographic coordinates.
+ *
+ * @see https://geojson.org/geojson-spec.html#point
+ *
+ * @property {"Point"} type - The type of the geometry, which is always "Point" for a GeoJSON point.
+ * @property {[number, number]} coordinates - The coordinates of the point, represented as [longitude, latitude].
+ */
 export type GeoPoint = {
   type: "Point";
   coordinates: [number, number];

package/src/rest/types/organizations/events/index.ts

@@ -35,10 +35,6 @@ export type OrganizationEvent = Base & {
   endAt: Date;
 };
 
-export type OrganizationEventWithDistance = OrganizationEvent & {
-  distance: number;
-};
-
 export enum OrganizationEventType {
   Clubbing = "clubbing",
   Concert = "concert",
@@ -108,6 +104,12 @@ export type OrganizationEventEndpoints =
       OrganizationEvent,
       CreateOrganizationEventDto
     >
+  | Endpoint<
+      "POST",
+      "/organizations/:organizationSlug/events/:eventSlug/views",
+      boolean,
+      null
+    >
   | Endpoint<
       "PUT",
       "/organizations/:organizationSlug/events/:eventSlug",

package/tests/dtos/index.ts

@@ -0,0 +1,157 @@
+import assert from "assert";
+import { plainToInstance } from "class-transformer";
+import { validate, ValidationError } from "class-validator";
+import test from "node:test";
+
+import {
+  CreateUserDto,
+  CreateOrganizationEventTicketDto,
+} from "../../src/rest/dtos";
+import {
+  UserIdentityGender,
+  OrganizationEventTicketType,
+  OrganizationEventTicketCategory,
+  Currency,
+} from "../../src/rest/types";
+
+function printValidationErrors(errors: ValidationError[]): string[] {
+  const formatError = (error: ValidationError, prefix = ""): string[] => {
+    let messages: string[] = [];
+    if (error.constraints) {
+      Object.entries(error.constraints).forEach(([key, value]) => {
+        messages.push(`${prefix}${error.property} - ${key}: ${value}`);
+      });
+    }
+    if (error.children) {
+      error.children.forEach((child: ValidationError) => {
+        messages = messages.concat(
+          formatError(child, `${prefix}${error.property}.`),
+        );
+      });
+    }
+    return messages;
+  };
+
+  return errors.flatMap((error) => formatError(error));
+}
+
+export async function dtoTests() {
+  test("CreateUserDto validation", async (t) => {
+    await t.test("should fail with invalid email", async () => {
+      const dto = plainToInstance(CreateUserDto, {
+        identifier: {
+          email: "invalid-email",
+          username: "validuser123",
+        },
+        identity: {
+          firstName: "John",
+          lastName: "Doe",
+          gender: UserIdentityGender.Male,
+          birthDate: new Date().toISOString(),
+        },
+        password: "ValidPass123!",
+      });
+
+      const identifierErrors = await validate(dto.identifier);
+      const hasEmailError = identifierErrors.some(
+        (error) => error.property === "email" && error.constraints?.isEmail,
+      );
+
+      assert(hasEmailError, "Expected validation error for invalid email");
+    });
+
+    await t.test("should fail with invalid password", async () => {
+      const dto = plainToInstance(CreateUserDto, {
+        identifier: {
+          email: "test@example.com",
+          username: "validuser123",
+        },
+        identity: {
+          firstName: "John",
+          lastName: "Doe",
+          gender: UserIdentityGender.Male,
+          birthDate: new Date().toISOString(),
+        },
+        password: "weak",
+      });
+
+      const errors = await validate(dto, {
+        skipMissingProperties: false,
+      });
+
+      const hasPasswordError = errors.some(
+        (error) => error.property === "password" && error.constraints?.matches,
+      );
+
+      assert(hasPasswordError, "Expected validation error for weak password");
+    });
+
+    await t.test("should pass with valid DTO", async () => {
+      const dto = plainToInstance(CreateUserDto, {
+        identifier: {
+          email: "test@example.com",
+          username: "validuser123",
+        },
+        identity: {
+          firstName: "John",
+          lastName: "Doe",
+          gender: UserIdentityGender.Male,
+          birthDate: new Date().toISOString(),
+        },
+        password: "ValidPass123!",
+      });
+
+      const error = await validate(dto.identifier);
+      const identityError = await validate(dto.identity);
+      const mainError = await validate(dto, {
+        whitelist: true,
+        forbidNonWhitelisted: true,
+      });
+
+      const totalErrors =
+        error.length + identityError.length + mainError.length;
+      assert.strictEqual(totalErrors, 0, "Expected no validation errors");
+    });
+  });
+
+  test("CreateOrganizationEventTicketDto validation", async (t) => {
+    await t.test("should pass with valid DTO", async () => {
+      const dto = plainToInstance(CreateOrganizationEventTicketDto, {
+        name: "VIP Ticket",
+        description:
+          "Access to VIP area, minimum length should be at least 16 chars",
+        price: 100,
+        quantity: 100,
+        type: OrganizationEventTicketType.ETicket,
+        category: OrganizationEventTicketCategory.Entry,
+        currency: Currency.EUR,
+        isVisible: true,
+        isFeesIncluded: true,
+      });
+
+      const errors = await validate(dto);
+      assert.strictEqual(errors.length, 0, "Expected no validation errors");
+    });
+
+    await t.test("should fail with invalid price", async () => {
+      const dto = plainToInstance(CreateOrganizationEventTicketDto, {
+        name: "VIP Ticket",
+        description:
+          "Access to VIP area, minimum length should be at least 16 chars",
+        price: -10,
+        quantity: 100,
+        type: OrganizationEventTicketType.ETicket,
+        category: OrganizationEventTicketCategory.Entry,
+        currency: Currency.EUR,
+        isVisible: true,
+        isFeesIncluded: true,
+      });
+
+      const errors = await validate(dto);
+      const hasPriceError = printValidationErrors(errors).some(
+        (error) => error.includes("price") && error.includes("min"),
+      );
+      assert(hasPriceError, "Expected validation error for negative price");
+    });
+  });
+}

package/tests/index.ts

@@ -5,11 +5,12 @@ import test from "node:test";
 
 import { authTests } from "./auth";
 import { careersTests } from "./careers";
+import { dtoTests } from "./dtos";
 import { regexTests } from "./regex";
 import { usersTests } from "./users";
 import { TonightPass } from "../src/tonightpass";
 
-const sdkTests = [authTests, careersTests, regexTests, usersTests];
+const sdkTests = [authTests, careersTests, dtoTests, regexTests, usersTests];
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-expect-error