hh-contracts 0.0.95 → 0.0.97

package/hotels/integrations/contracts/create-hotel-integration.contract.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import {
+  HotelIntegrationDetailSchema,
+  HotelIntegrationWriteSchema,
+} from '../hotel-integration.model';
+
+export namespace CreateHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.create;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.create;
+  export const httpMethod = HTTP_METHODS.post;
+
+  export const RequestSchema = HotelIntegrationWriteSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelIntegrationDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string };
+}

package/hotels/integrations/contracts/delete-hotel-integration.contract.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+
+export namespace DeleteHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.delete;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.delete;
+  export const httpMethod = HTTP_METHODS.delete;
+
+  export const ResponseSchema = z.void();
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string; integrationId: string };
+}

package/hotels/integrations/contracts/find-all-hotel-integrations.contract.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import { HotelIntegrationSchema } from '../hotel-integration.model';
+
+export namespace FindAllHotelIntegrationsContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.findAll;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.findAll;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = z.array(HotelIntegrationSchema);
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string };
+}

package/hotels/integrations/contracts/find-hotel-integration.contract.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import { HotelIntegrationDetailSchema } from '../hotel-integration.model';
+
+export namespace FindHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.findOne;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.findOne;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = HotelIntegrationDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string; integrationId: string };
+}

package/hotels/integrations/contracts/index.ts

@@ -0,0 +1,5 @@
+export * from './find-all-hotel-integrations.contract';
+export * from './find-hotel-integration.contract';
+export * from './create-hotel-integration.contract';
+export * from './update-hotel-integration.contract';
+export * from './delete-hotel-integration.contract';

package/hotels/integrations/contracts/update-hotel-integration.contract.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_INTEGRATIONS_API, HOTEL_INTEGRATIONS_CONTROLLER } from '../hotel-integrations.api';
+import {
+  HotelIntegrationDetailSchema,
+  HotelIntegrationWriteSchema,
+} from '../hotel-integration.model';
+
+export namespace UpdateHotelIntegrationContract {
+  export const getUrl = HOTEL_INTEGRATIONS_API.update;
+  export const endpoint = HOTEL_INTEGRATIONS_CONTROLLER.endpoints.update;
+  export const httpMethod = HTTP_METHODS.put;
+
+  export const RequestSchema = HotelIntegrationWriteSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelIntegrationDetailSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+
+  export type TPathParams = { hotelId: string; integrationId: string };
+}

package/hotels/integrations/hotel-integration.model.ts

@@ -0,0 +1,80 @@
+import * as z from 'zod';
+import { SlugSchema, TimestampSchema } from '../../common';
+import {
+  HOTEL_INTEGRATION_CONNECTION_STATE_VALUES,
+  HOTEL_INTEGRATION_CREDENTIAL_STATUS_VALUES,
+  HOTEL_INTEGRATION_PROVIDER_VALUES,
+  HOTEL_INTEGRATION_SYNC_STATUS_VALUES,
+} from '../constants';
+import { OperaIntegrationConfigSchema } from './configs';
+
+export const HotelIntegrationConfigSchema = z.discriminatedUnion('provider', [
+  OperaIntegrationConfigSchema,
+]);
+
+export const HotelIntegrationSchema = z.object({
+  alias: SlugSchema,
+  config: HotelIntegrationConfigSchema,
+  credentialId: z.uuid().nullable().optional(),
+});
+export type THotelIntegration = z.infer<typeof HotelIntegrationSchema>;
+
+export const HotelIntegrationPersistedSchema = HotelIntegrationSchema.required({
+  credentialId: true,
+}).extend({
+  id: z.uuid(),
+  secretHash: z.string().min(1),
+  secretSalt: z.string().min(1),
+  ...TimestampSchema.shape,
+});
+
+export const HotelIntegrationWriteSchema = HotelIntegrationSchema;
+export type THotelIntegrationWrite = z.infer<typeof HotelIntegrationWriteSchema>;
+
+export const HotelIntegrationDetailSchema = HotelIntegrationPersistedSchema.omit({
+  secretHash: true,
+  secretSalt: true,
+});
+export type THotelIntegrationDetail = z.infer<typeof HotelIntegrationDetailSchema>;
+
+export const HotelIntegrationHotelSchema = z
+  .object({
+    id: z.uuid(),
+    integrationId: z.uuid(),
+    hotelId: z.uuid(),
+    hotelExternalId: z.string(),
+    isActive: z.boolean().default(true),
+  })
+  .extend(TimestampSchema.shape);
+export type THotelIntegrationHotel = z.infer<typeof HotelIntegrationHotelSchema>;
+
+export const HotelIntegrationConnectionSchema = z
+  .object({
+    id: z.uuid(),
+    integrationId: z.uuid(),
+    connectionState: z.enum(HOTEL_INTEGRATION_CONNECTION_STATE_VALUES),
+    lastHeartbeatAt: z.date(),
+    lastSeenAt: z.date(),
+    lastSyncStatus: z.enum(HOTEL_INTEGRATION_SYNC_STATUS_VALUES),
+    lastSyncAt: z.date().nullable(),
+    failedAt: z.date().nullable(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .extend(TimestampSchema.shape);
+export type THotelIntegrationConnection = z.infer<typeof HotelIntegrationConnectionSchema>;
+
+export const HotelIntegrationCredentialSchema = z
+  .object({
+    id: z.uuid(),
+    integrationId: z.uuid(),
+    provider: z.enum(HOTEL_INTEGRATION_PROVIDER_VALUES),
+    login: z.string().min(1),
+    encryptedSecret: z.string().min(1),
+    encryptionVersion: z.string().min(1),
+    status: z.enum(HOTEL_INTEGRATION_CREDENTIAL_STATUS_VALUES),
+    expiresAt: z.date().nullable(),
+    meta: z.record(z.string(), z.unknown()).optional(),
+    rotatedAt: z.date().nullable(),
+  })
+  .extend(TimestampSchema.shape);
+export type THotelIntegrationCredential = z.infer<typeof HotelIntegrationCredentialSchema>;

package/hotels/integrations/hotel-integrations.api.ts

@@ -0,0 +1,16 @@
+import { createApi, TController } from '../../common/utils';
+
+export const HOTEL_INTEGRATIONS_CONTROLLER = {
+  prefix: 'hotels/by-id/:hotelId/integrations',
+  endpoints: {
+    findAll: 'findAll',
+    findOne: ':integrationId',
+    create: '',
+    update: ':integrationId',
+    delete: ':integrationId',
+    enable: ':integrationId/enable',
+    disable: ':integrationId/disable',
+  },
+} as const satisfies TController;
+
+export const HOTEL_INTEGRATIONS_API = createApi(HOTEL_INTEGRATIONS_CONTROLLER);

package/hotels/integrations/index.ts

@@ -0,0 +1,3 @@
+export * from './hotel-integration.model';
+export * from './hotel-integrations.api';
+export * from './contracts';

package/hotels/location/hotel-location.model.ts

@@ -0,0 +1,17 @@
+import * as z from 'zod';
+import { TimestampSchema } from '../../common';
+
+export const HotelLocationSchema = z
+  .object({
+    hotelId: z.uuid(),
+    countryCode: z.string().length(2),
+    regionCode: z.string().max(32).optional(),
+    city: z.string().min(1).max(128),
+    addressLine1: z.string().min(1).max(256),
+    addressLine2: z.string().max(256).optional(),
+    postalCode: z.string().max(16).optional(),
+    latitude: z.number().min(-90).max(90),
+    longitude: z.number().min(-180).max(180),
+  })
+  .extend(TimestampSchema.shape);
+export type THotelLocation = z.infer<typeof HotelLocationSchema>;

package/hotels/location/index.ts

@@ -0,0 +1 @@
+export * from './hotel-location.model';

package/hotels/policies/hotel-policy.model.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import { TimestampSchema } from '../../common';
+import { HOTEL_POLICY_TYPE_VALUES } from '../constants';
+
+export const HotelPolicySchema = z
+  .object({
+    hotelId: z.uuid(),
+    policyType: z.enum(HOTEL_POLICY_TYPE_VALUES),
+    valueKey: z.string().min(1).optional(),
+    valueJson: z.record(z.string(), z.unknown()).optional(),
+    effectiveFrom: z.date().optional(),
+    effectiveTo: z.date().optional(),
+  })
+  .extend(TimestampSchema.shape);
+
+export type THotelPolicy = z.infer<typeof HotelPolicySchema>;

package/hotels/policies/index.ts

@@ -0,0 +1 @@
+export * from './hotel-policy.model';

package/hotels/ratings/hotel-rating.model.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import { IsoDatetimeSchema, TimestampSchema } from '../../common';
+import { HOTEL_RATING_SOURCE_VALUES } from '../constants';
+
+export const HotelRatingSchema = z
+  .object({
+    hotelId: z.uuid(),
+    source: z.enum(HOTEL_RATING_SOURCE_VALUES),
+    value: z.number().min(0).max(10),
+    reviewsCount: z.number().int().nonnegative().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .extend(TimestampSchema.shape);
+
+export type THotelRating = z.infer<typeof HotelRatingSchema>;

package/hotels/ratings/index.ts

@@ -0,0 +1 @@
+export * from './hotel-rating.model';

package/hotels/sites/contracts/find-hotel-site-page-by-lang.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS, LanguageKeysSchema } from '../../../common';
-import { HOTELS_BY_SLUG_API, HOTELS_BY_SLUG_CONTROLLER } from '../../hotels.api';
+import { HOTEL_PAGES_PUBLIC_API, HOTEL_PAGES_PUBLIC_CONTROLLER } from '../hotel-pages.api';
 import { PageLangTranslationSchema, PageSchema } from '../../../pages';
 
 const FindHotelSitePageByLangContractRequestSchema = z.object({
@@ -14,8 +14,8 @@ const FindHotelSitePageByLangContractResponseSchema = PageSchema.omit({
 });
 
 export namespace FindHotelSitePageByLangContract {
-  export const getUrl = HOTELS_BY_SLUG_API.findSitePageByLang;
-  export const endpoint = HOTELS_BY_SLUG_CONTROLLER.endpoints.findSitePageByLang;
+  export const getUrl = HOTEL_PAGES_PUBLIC_API.findBySlugAndLang;
+  export const endpoint = HOTEL_PAGES_PUBLIC_CONTROLLER.endpoints.findBySlugAndLang;
   export const httpMethod = HTTP_METHODS.get;
 
   export const RequestSchema = FindHotelSitePageByLangContractRequestSchema;

package/hotels/sites/hotel-pages.api.ts

@@ -0,0 +1,24 @@
+import { createApi, TController } from '../../common/utils';
+
+export const HOTEL_PAGES_CONTROLLER = {
+  prefix: 'hotels/by-id/:hotelId/sites/pages',
+  endpoints: {
+    findMany: '',
+    findBySlug: ':slug',
+    findBySlugAndLang: ':slug/lang/:lang',
+    create: '',
+    update: ':slug',
+    delete: ':slug',
+  },
+} as const satisfies TController;
+
+export const HOTEL_PAGES_PUBLIC_CONTROLLER = {
+  prefix: 'hotels/by-slug/:hotelSlug/sites/pages',
+  endpoints: {
+    findBySlug: ':slug',
+    findBySlugAndLang: ':slug/lang/:lang',
+  },
+} as const satisfies TController;
+
+export const HOTEL_PAGES_API = createApi(HOTEL_PAGES_CONTROLLER);
+export const HOTEL_PAGES_PUBLIC_API = createApi(HOTEL_PAGES_PUBLIC_CONTROLLER);

package/hotels/sites/index.ts

@@ -1 +1,2 @@
+export * from './hotel-pages.api';
 export * from './contracts';

package/hotels/themes/contracts/find-hotel-theme.contract.ts

@@ -1,11 +1,11 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../../common';
 import { ThemePersistedSchema } from '../theme.models';
-import { HOTELS_BY_SLUG_API, HOTELS_BY_SLUG_CONTROLLER } from '../../hotels.api';
+import { HOTEL_THEMES_PUBLIC_API, HOTEL_THEMES_PUBLIC_CONTROLLER } from '../hotel-themes.api';
 
 export namespace FindHotelThemeContract {
-  export const getUrl = HOTELS_BY_SLUG_API.findTheme;
-  export const endpoint = HOTELS_BY_SLUG_CONTROLLER.endpoints.findTheme;
+  export const getUrl = HOTEL_THEMES_PUBLIC_API.get;
+  export const endpoint = HOTEL_THEMES_PUBLIC_CONTROLLER.endpoints.get;
   export const httpMethod = HTTP_METHODS.get;
 
   export const ResponseSchema = ThemePersistedSchema;

package/hotels/themes/hotel-themes.api.ts

@@ -0,0 +1,20 @@
+import { createApi, TController } from '../../common/utils';
+
+export const HOTEL_THEMES_CONTROLLER = {
+  prefix: 'hotels/by-id/:hotelId/theme',
+  endpoints: {
+    get: '',
+    upsert: '',
+    delete: '',
+  },
+} as const satisfies TController;
+
+export const HOTEL_THEMES_PUBLIC_CONTROLLER = {
+  prefix: 'hotels/by-slug/:hotelSlug/theme',
+  endpoints: {
+    get: '',
+  },
+} as const satisfies TController;
+
+export const HOTEL_THEMES_API = createApi(HOTEL_THEMES_CONTROLLER);
+export const HOTEL_THEMES_PUBLIC_API = createApi(HOTEL_THEMES_PUBLIC_CONTROLLER);

package/hotels/themes/index.ts

@@ -1,3 +1,4 @@
 export * from './constants';
 export * from './theme.models';
+export * from './hotel-themes.api';
 export * from './contracts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hh-contracts",
-  "version": "0.0.95",
+  "version": "0.0.97",
   "description": "",
   "main": "./build/index.js",
   "scripts": {

package/permissions/contracts/create-permission.contract.ts

@@ -1,13 +1,9 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
-import { PermissionWithTranslationsSchema } from '../permission.models';
+import { PermissionWriteSchema, PermissionDetailSchema } from '../permission.models';
 
-const CreatePermissionContractRequestSchema = PermissionWithTranslationsSchema.omit({
-  id: true,
-  createdAt: true,
-  updatedAt: true,
-});
+const CreatePermissionContractRequestSchema = PermissionWriteSchema;
 
 export namespace CreatePermissionContract {
   export const getUrl = PERMISSIONS_API.create;
@@ -17,6 +13,6 @@ export namespace CreatePermissionContract {
   export const RequestSchema = CreatePermissionContractRequestSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = PermissionDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/contracts/delete-permission.contract.ts

@@ -1,13 +1,12 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
-import { PermissionWithTranslationsSchema } from '../permission.models';
 
 export namespace DeletePermissionContract {
   export const getUrl = PERMISSIONS_API.delete;
   export const endpoint = PERMISSIONS_CONTROLLER.endpoints.delete;
   export const httpMethod = HTTP_METHODS.delete;
 
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = z.void();
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/contracts/find-permission.contract.ts

@@ -1,21 +1,13 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { PermissionWithTranslationsSchema } from '../permission.models';
+import { PermissionDetailSchema } from '../permission.models';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
 
-// const FindPermissionContractResponseSchema = PersistedPermissionSchema.transform(
-//   ({ conditions, ...permission }) => ({
-//     ...permission,
-//     conditions: conditions === null ? undefined : conditions,
-//   }),
-// );
-
 export namespace FindPermissionContract {
   export const getUrl = PERMISSIONS_API.find;
   export const endpoint = PERMISSIONS_CONTROLLER.endpoints.find;
   export const httpMethod = HTTP_METHODS.get;
 
-  // export const ResponseSchema = FindPermissionContractResponseSchema;
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = PermissionDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/contracts/update-permission.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { PermissionWithTranslationsSchema } from '../permission.models';
+import { PermissionDetailSchema } from '../permission.models';
 import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
 import { CreatePermissionContract } from './create-permission.contract';
 
@@ -12,6 +12,6 @@ export namespace UpdatePermissionContract {
   export const RequestSchema = CreatePermissionContract.RequestSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = PermissionWithTranslationsSchema;
+  export const ResponseSchema = PermissionDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/permission.models.ts

@@ -1,47 +1,34 @@
 import * as z from 'zod';
-import { AppAbility, TimestampSchema, makeTranslations } from '../common';
+import { AppAbility, TimestampSchema, UuidSchema, makeTranslations } from '../common';
 
-export const JsonConditionsSchema = z
-  .string()
-  .transform(val => (val === '' ? undefined : val))
-  .optional()
-  .nullable()
-  .refine(
-    val => {
-      if (val === undefined || val === null) return true;
-      try {
-        JSON.parse(val);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    { params: { messageKey: 'errors.validation.invalidJson' } },
-  );
-
-export const PermissionPersistedSchema = z
-  .object({
-    id: z.uuid(),
-
-    action: z.enum(AppAbility.ACTION_VALUES),
-    subject: z.enum(AppAbility.SUBJECT_VALUES),
-    conditions: JsonConditionsSchema,
-  })
-  .extend(TimestampSchema.shape);
+export const PermissionSchema = z.object({
+  action: z.enum(AppAbility.ACTION_VALUES),
+  subject: z.enum(AppAbility.SUBJECT_VALUES),
+  conditions: z.json().nullable().optional(),
+});
+export type TPermission = z.infer<typeof PermissionSchema>;
 
+export const PermissionPersistedSchema = PermissionSchema.required({ conditions: true }).extend({
+  id: UuidSchema,
+  ...TimestampSchema.shape,
+});
 export type TPermissionPersisted = z.infer<typeof PermissionPersistedSchema>;
 
-// V2 translations: all translatable fields are inside per-language translation object
 export const PermissionTranslationsSchema = z.object({
   name: z.string().min(3),
   description: z.string().optional(),
 });
 export type TPermissionTranslations = z.infer<typeof PermissionTranslationsSchema>;
 
-export const PermissionWithTranslationsSchema = PermissionPersistedSchema.extend({
+export const PermissionWriteSchema = PermissionSchema.extend({
+  translations: makeTranslations(PermissionTranslationsSchema),
+});
+export type TPermissionWrite = z.infer<typeof PermissionWriteSchema>;
+
+export const PermissionDetailSchema = PermissionPersistedSchema.extend({
   translations: makeTranslations(PermissionTranslationsSchema),
 });
-export type TPermissionWithTranslations = z.infer<typeof PermissionWithTranslationsSchema>;
+export type TPermissionDetail = z.infer<typeof PermissionDetailSchema>;
 
 export const PermissionListItemSchema = PermissionPersistedSchema.extend({
   name: z.string().nullable(),

package/roles/contracts/create-role.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
+import { RoleWriteSchema, RoleDetailSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 
 export namespace CreateRoleContract {
@@ -8,13 +8,9 @@ export namespace CreateRoleContract {
   export const endpoint = ROLES_CONTROLLER.endpoints.create;
   export const httpMethod = HTTP_METHODS.post;
 
-  export const RequestSchema = RoleWithTranslationsSchema.omit({
-    id: true,
-    createdAt: true,
-    updatedAt: true,
-  });
+  export const RequestSchema = RoleWriteSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = RoleDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/contracts/delete-role.contract.ts

@@ -1,6 +1,5 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 
 export namespace DeleteRoleContract {
@@ -8,6 +7,6 @@ export namespace DeleteRoleContract {
   export const endpoint = ROLES_CONTROLLER.endpoints.delete;
   export const httpMethod = HTTP_METHODS.delete;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = z.void();
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/contracts/find-role.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
+import { RoleDetailSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 
 export namespace FindRoleContract {
@@ -8,6 +8,6 @@ export namespace FindRoleContract {
   export const endpoint = ROLES_CONTROLLER.endpoints.find;
   export const httpMethod = HTTP_METHODS.get;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = RoleDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/contracts/update-role.contract.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod';
 import { HTTP_METHODS } from '../../common';
-import { RoleWithTranslationsSchema } from '../role.models';
+import { RoleDetailSchema } from '../role.models';
 import { ROLES_API, ROLES_CONTROLLER } from '../roles.api';
 import { CreateRoleContract } from './create-role.contract';
 
@@ -12,6 +12,6 @@ export namespace UpdateRoleContract {
   export const RequestSchema = CreateRoleContract.RequestSchema;
   export type TRequest = z.infer<typeof RequestSchema>;
 
-  export const ResponseSchema = RoleWithTranslationsSchema;
+  export const ResponseSchema = RoleDetailSchema;
   export type TResponse = z.infer<typeof ResponseSchema>;
 }

package/roles/role.models.ts

@@ -1,21 +1,25 @@
 import * as z from 'zod';
-import { ROLE_TYPE_VALUES, TimestampSchema, UuidArraySchema, makeTranslations } from '../common';
+import {
+  ROLE_TYPE_VALUES,
+  TimestampSchema,
+  UuidArraySchema,
+  UuidSchema,
+  makeTranslations,
+} from '../common';
 import { PermissionListItemSchema } from '../permissions';
 
-export const RolePersistedSchema = z
-  .object({
-    id: z.uuid(),
-    type: z.enum(ROLE_TYPE_VALUES),
-    isActive: z.boolean().default(true),
-    isDefault: z.boolean().default(false),
-  })
-  .extend(TimestampSchema.shape);
-export type TRolePersisted = z.infer<typeof RolePersistedSchema>;
+export const RoleSchema = z.object({
+  type: z.enum(ROLE_TYPE_VALUES),
+  isActive: z.boolean().optional(),
+  isDefault: z.boolean().optional(),
+});
+export type TRole = z.infer<typeof RoleSchema>;
 
-export const RoleWithPermissionsSchema = RolePersistedSchema.extend({
-  permissionIds: UuidArraySchema.optional(),
+export const RolePersistedSchema = RoleSchema.required({ isActive: true, isDefault: true }).extend({
+  id: UuidSchema,
+  ...TimestampSchema.shape,
 });
-export type TRoleWithPermissions = z.infer<typeof RoleWithPermissionsSchema>;
+export type TRolePersisted = z.infer<typeof RolePersistedSchema>;
 
 export const RoleTranslationsSchema = z.object({
   name: z.string().min(3),
@@ -23,10 +27,17 @@ export const RoleTranslationsSchema = z.object({
 });
 export type TRoleTranslations = z.infer<typeof RoleTranslationsSchema>;
 
-export const RoleWithTranslationsSchema = RoleWithPermissionsSchema.extend({
+export const RoleWriteSchema = RoleSchema.extend({
   translations: makeTranslations(RoleTranslationsSchema),
+  permissionIds: UuidArraySchema.optional(),
+});
+export type TRoleWrite = z.infer<typeof RoleWriteSchema>;
+
+export const RoleDetailSchema = RolePersistedSchema.extend({
+  translations: makeTranslations(RoleTranslationsSchema),
+  permissionIds: UuidArraySchema.optional(),
 });
-export type TRoleWithTranslations = z.infer<typeof RoleWithTranslationsSchema>;
+export type TRoleDetail = z.infer<typeof RoleDetailSchema>;
 
 export const RoleListItemSchema = RolePersistedSchema.extend({
   name: z.string().nullable(),