hh-contracts 0.0.94 → 0.0.96

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

@@ -0,0 +1,29 @@
+import * as z from 'zod';
+import { TimestampSchema } from '../../common';
+import { HOTEL_INTEGRATION_PROVIDER_VALUES } from '../constants';
+
+export const HotelIntegrationSchema = z
+  .object({
+    hotelId: z.uuid(),
+    provider: z.enum(HOTEL_INTEGRATION_PROVIDER_VALUES),
+    externalHotelId: z.string().min(1),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    credentialId: z.uuid().optional(),
+  })
+  .extend(TimestampSchema.shape);
+
+export type THotelIntegration = z.infer<typeof HotelIntegrationSchema>;
+
+export const HotelIntegrationCredentialSchema = z
+  .object({
+    id: z.uuid(),
+    provider: z.enum(HOTEL_INTEGRATION_PROVIDER_VALUES),
+    login: z.string().min(1),
+    encryptedSecret: z.string().min(1),
+    encryptionVersion: z.string().min(1),
+    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: {
+    findMany: '',
+    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,2 @@
+export * from './hotel-integration.model';
+export * from './hotel-integrations.api';

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/settings/contracts/find-hotel-domain-settings.contract.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_DOMAIN_SETTINGS_API, HOTEL_DOMAIN_SETTINGS_CONTROLLER } from '../hotel-domain-settings.api';
+import { HotelDomainSettingsListSchema } from '../hotel-domain-settings.schema';
+
+export namespace FindHotelDomainSettingsContract {
+  export const getUrl = HOTEL_DOMAIN_SETTINGS_API.find;
+  export const endpoint = HOTEL_DOMAIN_SETTINGS_CONTROLLER.endpoints.find;
+  export const httpMethod = HTTP_METHODS.get;
+
+  export const ResponseSchema = HotelDomainSettingsListSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/hotels/settings/contracts/index.ts

@@ -0,0 +1,2 @@
+export * from './find-hotel-domain-settings.contract';
+export * from './update-hotel-domain-settings.contract';

package/hotels/settings/contracts/update-hotel-domain-settings.contract.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+import { HTTP_METHODS } from '../../../common';
+import { HOTEL_DOMAIN_SETTINGS_API, HOTEL_DOMAIN_SETTINGS_CONTROLLER } from '../hotel-domain-settings.api';
+import {
+  HotelDomainSettingsPersistedSchema,
+  HotelDomainSettingsSchema,
+} from '../hotel-domain-settings.schema';
+
+export namespace UpdateHotelDomainSettingsContract {
+  export const getUrl = HOTEL_DOMAIN_SETTINGS_API.update;
+  export const endpoint = HOTEL_DOMAIN_SETTINGS_CONTROLLER.endpoints.update;
+  export const httpMethod = HTTP_METHODS.put;
+
+  export const RequestSchema = HotelDomainSettingsSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = HotelDomainSettingsPersistedSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/hotels/settings/hotel-domain-settings.api.ts

@@ -0,0 +1,11 @@
+import { createApi, TController } from '../../common/utils';
+
+export const HOTEL_DOMAIN_SETTINGS_CONTROLLER = {
+  prefix: 'hotels/by-id/:hotelId/settings/domains',
+  endpoints: {
+    find: '',
+    update: '',
+  },
+} as const satisfies TController;
+
+export const HOTEL_DOMAIN_SETTINGS_API = createApi(HOTEL_DOMAIN_SETTINGS_CONTROLLER);

package/hotels/settings/hotel-domain-settings.schema.ts

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+import {
+  DomainNameSchema,
+  IsoDatetimeSchema,
+  KIND_OF_APP_VALUES,
+  TimestampSchema,
+} from '../../common';
+
+export const HotelDomainSettingsSchema = z.object({
+  kindOfApp: z.enum(KIND_OF_APP_VALUES),
+  customDomain: DomainNameSchema.optional(),
+  isCustomDomainVerified: z.boolean().default(false),
+  customDomainVerifiedAt: IsoDatetimeSchema.optional(),
+});
+
+export const HotelDomainSettingsPersistedSchema = HotelDomainSettingsSchema.extend({
+  id: z.uuid(),
+  hotelId: z.uuid(),
+}).extend(TimestampSchema.shape);
+
+export const HotelDomainSettingsListSchema = z.array(HotelDomainSettingsPersistedSchema);
+
+export type THotelDomainSettings = z.infer<typeof HotelDomainSettingsSchema>;
+export type THotelDomainSettingsPersisted = z.infer<typeof HotelDomainSettingsPersistedSchema>;

package/hotels/settings/index.ts

@@ -0,0 +1,3 @@
+export * from './hotel-domain-settings.schema';
+export * from './hotel-domain-settings.api';
+export * from './contracts';

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.94",
+  "version": "0.0.96",
   "description": "",
   "main": "./build/index.js",
   "scripts": {

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

@@ -3,19 +3,11 @@ import { HTTP_METHODS } from '../../common';
 import { PermissionWithTranslationsSchema } 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 type TResponse = z.infer<typeof ResponseSchema>;
 }

package/permissions/permission.models.ts

@@ -1,31 +1,13 @@
 import * as z from 'zod';
 import { AppAbility, TimestampSchema, 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,
+    conditions: z.json().optional().nullable(),
   })
   .extend(TimestampSchema.shape);
 

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/translate/contracts/translate-object.contract.ts

@@ -4,6 +4,7 @@ import { TRANSLATE_API, TRANSLATE_CONTROLLER } from '../translate.api';
 import { PermissionTranslationsSchema } from '../../permissions';
 import { RoleTranslationsSchema } from '../../roles';
 import { BaseTranslateSchema } from '../translate.schemas';
+import { HotelTranslationsSchema } from '../../hotels';
 
 const makeReqVariant = <E extends TEntity, S extends z.ZodObject>(entity: E, schema: S) =>
   z.object({
@@ -21,11 +22,13 @@ const makeResVariant = <E extends TEntity, S extends z.ZodTypeAny>(entity: E, sc
 const TranslateObjectRequestVariants = [
   makeReqVariant(ENTITIES.permission, PermissionTranslationsSchema),
   makeReqVariant(ENTITIES.role, RoleTranslationsSchema),
+  makeReqVariant(ENTITIES.hotel, HotelTranslationsSchema),
 ] as const;
 
 const TranslateObjectResponseVariants = [
   makeResVariant(ENTITIES.permission, PermissionTranslationsSchema),
   makeResVariant(ENTITIES.role, RoleTranslationsSchema),
+  makeResVariant(ENTITIES.hotel, HotelTranslationsSchema),
 ] as const;
 
 const TranslateObjectContractRequestSchema = BaseTranslateSchema.extend({

package/build/permissions/permission.response.schema.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PermissionResponseSchema = void 0;
-const permission_models_1 = require("./permission.models");
-exports.PermissionResponseSchema = permission_models_1.PermissionPersistedSchema.transform(({ conditions, ...rest }) => ({
-    ...rest,
-    conditions: conditions ? JSON.parse(conditions) : undefined,
-}));

package/hotels/hotel.model.ts

@@ -1,14 +0,0 @@
-import * as z from 'zod';
-import { LANGUAGE_KEYS, TimestampSchema, AppStatuses, SlugSchema } from '../common';
-
-export const HotelPersistedSchema = z
-  .object({
-    id: z.uuid(),
-    slug: SlugSchema,
-    status: z.enum(AppStatuses.HOTEL_VALUES),
-    hasServices: z.boolean(),
-    defaultLang: z.enum(LANGUAGE_KEYS),
-    availableLangs: z.array(z.enum(LANGUAGE_KEYS)),
-  })
-  .extend(TimestampSchema.shape);
-export type THotelPersisted = z.infer<typeof HotelPersistedSchema>;

package/permissions/permission.response.schema.ts

@@ -1,8 +0,0 @@
-import { PermissionPersistedSchema } from './permission.models';
-
-export const PermissionResponseSchema = PermissionPersistedSchema.transform(
-  ({ conditions, ...rest }) => ({
-    ...rest,
-    conditions: conditions ? JSON.parse(conditions) : undefined,
-  }),
-);