hh-contracts 0.0.5 → 0.0.7

package/common/constants/route-component-key.constants.ts

@@ -0,0 +1,5 @@
+export const ROUTE_COMPONENT_KEY = {
+  NavigationItem: 'navigation-item',
+} as const;
+
+export type TRouteComponentKey = (typeof ROUTE_COMPONENT_KEY)[keyof typeof ROUTE_COMPONENT_KEY];

package/common/index.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './models';
+export * from './transforms';
+export * from './types';
+export * from './utils';

package/common/models/icon-key.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { ICON_KEY } from '../constants';
+
+export const IconKeySchema = z.nativeEnum(ICON_KEY);

package/common/models/index.ts

@@ -0,0 +1,8 @@
+export * from './icon-key.schema';
+export * from './info.schema';
+export * from './json.schema';
+export * from './navigation-item.schemas';
+export * from './order.schema';
+export * from './pagination.schema';
+export * from './search.schema';
+export * from './timestamp.schemas';

package/common/models/json.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+type Literal = z.infer<typeof literalSchema>;
+export type Json = Literal | { [key: string]: Json } | Json[];
+export const JsonSchema: z.ZodType<Json> = z.lazy(() =>
+  z.union([literalSchema, z.array(JsonSchema), z.record(JsonSchema)]),
+);

package/common/models/navigation-item.schemas.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { ROUTE_COMPONENT_KEY } from '../constants';
+import { NAVIGATION_ITEM_TYPE } from '../constants';
+import { IconKeySchema } from './icon-key.schema';
+import { TimestampSchema } from './timestamp.schemas';
+
+export const NavigationItemEntityBaseSchema = z
+  .object({
+    id: z.number().int().positive(),
+    parentId: z.nullable(z.number().int().positive()),
+    label: z.string().min(1),
+    description: z.nullable(z.string().min(1)),
+    iconKey: z.nullable(IconKeySchema),
+    link: z.nullable(z.string().min(1)),
+    routeComponentKey: z.nullable(z.nativeEnum(ROUTE_COMPONENT_KEY)),
+    type: z.nativeEnum(NAVIGATION_ITEM_TYPE),
+    disabled: z.boolean(),
+    order: z.number().int().positive(),
+  })
+  .merge(TimestampSchema);
+
+export type TNavigationItemEntityBase = z.infer<typeof NavigationItemEntityBaseSchema>;
+export type TNavigationItemEntity = TNavigationItemEntityBase & {
+  children?: TNavigationItemEntity[];
+};
+export const NavigationItemEntitySchema: z.ZodType<TNavigationItemEntity> =
+  NavigationItemEntityBaseSchema.extend({
+    children: z.lazy(() => z.array(NavigationItemEntitySchema).optional()),
+  });

package/common/models/order.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ORDER_DIRECTION } from '../constants/order-direction.constant';
+
+export const OrderSchema = z.object({
+  orderDir: z.nativeEnum(ORDER_DIRECTION).optional(),
+});

package/common/models/pagination.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { DEFAULT_PAGINATION_CONFIG } from '../constants';
+
+export const PaginationSchema = z.object({
+  page: z.coerce.number().positive().default(DEFAULT_PAGINATION_CONFIG.page),
+  pageSize: z.coerce
+    .number()
+    .positive()
+    .default(DEFAULT_PAGINATION_CONFIG.pageSize)
+    .transform(val => Math.min(val, DEFAULT_PAGINATION_CONFIG.maxPageSize)),
+  total: z.coerce.number().positive(),
+});

package/common/models/search.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { PaginationSchema } from './pagination.schema';
+
+export const SearchSchema = PaginationSchema.pick({
+  page: true,
+  pageSize: true,
+}).extend({
+  searchText: z.string().min(1).optional(),
+});

package/common/models/timestamp.schemas.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const TimestampSchema = z.object({
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const TimestampWithDeletedSchema = TimestampSchema.extend({
+  deletedAt: z.date().nullable(),
+});

package/{transforms → common/transforms}/navigation-item.transform.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { NavigationItemEntityBaseSchema, NavigationItemEntitySchema } from '../models';
+import { TDeepOptionalize } from '../types';
 
 const NavigationItemBase = NavigationItemEntityBaseSchema.transform(
   ({
@@ -28,11 +29,11 @@ type TInput = z.input<typeof NavigationItemEntityBaseSchema> & {
 type TOutput = z.output<typeof NavigationItemBase> & {
   children?: TOutput[];
 };
-export type TNavigationItem = z.ZodType<TOutput, z.ZodTypeDef, TInput>;
 
-export const NavigationItem: TNavigationItem = z.lazy(() =>
+export const NavigationItem: z.ZodType<TOutput, z.ZodTypeDef, TInput> = z.lazy(() =>
   NavigationItemEntitySchema.transform(({ children, ...rest }) => ({
     ...NavigationItemBase.parse(rest),
     children: children?.length ? children.map(child => NavigationItem.parse(child)) : undefined,
   })),
 );
+export type TNavigationItem = TDeepOptionalize<z.infer<typeof NavigationItem>>;

package/common/types/index.ts

@@ -0,0 +1,2 @@
+export * from './zod.type';
+export * from './optionalized.type';

package/common/types/optionalized.type.ts

@@ -0,0 +1,40 @@
+/**
+ * Utility type that converts properties of T that include undefined to optional properties.
+ *
+ * Для каждого ключа K, если undefined расширяет T[K] (то есть T[K] содержит undefined),
+ * то в результирующем типе свойство K становится опциональным, а его тип – Exclude<T[K], undefined>.
+ */
+export type TOptionalize<T> = {
+  [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
+} & {
+  [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+
+/**
+ * Helper type to merge intersections into a single object type.
+ */
+export type TMerge<T> = { [K in keyof T]: T[K] };
+
+/**
+ * Итоговый утилитарный тип, который превращает свойства с undefined в опциональные.
+ */
+export type TOptionalized<T> = TMerge<TOptionalize<T>>;
+
+/**
+ * DeepOptionalize: Рекурсивно применяет Optionalize ко всем вложенным объектам и массивам.
+ */
+export type TDeepOptionalize<T> = T extends Date | null
+  ? T
+  : T extends Array<infer U>
+  ? Array<TDeepOptionalize<U>>
+  : T extends object
+  ? TMerge<
+      {
+        // Если свойство не допускает undefined, оставляем его обязательным
+        [K in keyof T as undefined extends T[K] ? never : K]: TDeepOptionalize<T[K]>;
+      } & {
+        // Если свойство допускает undefined, делаем его опциональным
+        [K in keyof T as undefined extends T[K] ? K : never]?: TDeepOptionalize<T[K]>;
+      }
+    >
+  : T;

package/common/utils/create-api/create-api.ts

@@ -0,0 +1,28 @@
+import { TApi, TController, TApiFunctionParams } from './types';
+// Универсальная функция для подстановки параметров в шаблонную строку.
+// Заменяет все вхождения вида ":key" на значение из объекта params.
+function substituteParams(template: string, params: Record<string, string | number>): string {
+  return template.replace(/:(\w+)/g, (_, key) => {
+    if (!(key in params)) {
+      throw new Error(`Missing parameter: ${key}`);
+    }
+    return String(params[key]);
+  });
+}
+
+// Функция генерации универсального API.
+export function createApi<T extends TController>({ prefix, endpoints }: T): TApi<T> {
+  const api = {} as TApi<T>;
+  for (const key in endpoints) {
+    // Для каждого эндпоинта возвращаем функцию, которая принимает объект параметров.
+    api[key as keyof T['endpoints']] = (
+      params?: TApiFunctionParams<T['prefix'], T['endpoints'][typeof key]>,
+    ) => {
+      const usedParams = params ?? {};
+      const computedPrefix = substituteParams(prefix, usedParams);
+      const computedEndpoint = substituteParams(endpoints[key], usedParams);
+      return `${computedPrefix}/${computedEndpoint}`;
+    };
+  }
+  return api;
+}

package/common/utils/create-api/index.ts

@@ -0,0 +1,2 @@
+export * from './create-api';
+export type { TApi, TController } from './types';

package/common/utils/create-api/types.ts

@@ -0,0 +1,34 @@
+// Извлекает динамические сегменты вида :param из строки-шаблона.
+type TExtractPathParams<S extends string> = S extends `${infer _Start}:${infer Param}/${infer Rest}`
+  ? Param | TExtractPathParams<`/${Rest}`>
+  : S extends `${infer _Start}:${infer Param}`
+  ? Param
+  : never;
+
+// Если в шаблонной строке нет динамических сегментов, возвращает пустой объект,
+// иначе – объект с ключами, равными извлечённым параметрам, и значениями типа string | number.
+type TParamsFromTemplate<S extends string> = TExtractPathParams<S> extends never
+  ? {}
+  : {
+      [K in TExtractPathParams<S> as K]: string | number;
+    };
+
+// Определение контроллера с шаблонным префиксом и эндпоинтами.
+// Эндпоинты задаются как строки, в которых можно использовать динамические сегменты.
+export type TController = {
+  prefix: string;
+  endpoints: Record<string, string>;
+};
+export type TApiFunctionParams<P extends string, E extends string> = TParamsFromTemplate<P> &
+  TParamsFromTemplate<E>;
+// Для каждого эндпоинта ожидаемые параметры – это объединение параметров из префикса и из самого эндпоинта.
+// Результирующий API: для каждого ключа из endpoints создаётся функция,
+// которая принимает параметры, объединяющие параметры из префикса контроллера и эндпоинта.
+export type TApi<
+  T extends TController,
+  TEndpoints extends Record<string, string> = T['endpoints'],
+> = {
+  [K in keyof T['endpoints']]: {} extends TApiFunctionParams<T['prefix'], TEndpoints[K]>
+    ? (params?: TApiFunctionParams<T['prefix'], TEndpoints[K]>) => string
+    : (params: TApiFunctionParams<T['prefix'], TEndpoints[K]>) => string;
+};

package/common/utils/index.ts

@@ -0,0 +1 @@
+export * from './create-api';

package/index.ts

@@ -1,5 +1,3 @@
-// export * from './api';
-export * from './dto';
-export * from './constants';
-export * from './models';
-export * from './transforms';
+export * from './common';
+export * from './app-menu';
+export * from './permissions';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hh-contracts",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "main": "index.js",
   "scripts": {

package/permissions/commands/create-permission.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { HTTP_METHOD, JsonSchema } from '../../common';
+import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
+import { PermissionSchema } from '../permission.model';
+
+const CreatePermissionCommandRequestSchema = PermissionSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+}).extend({
+  conditions: JsonSchema.optional().nullable(),
+});
+
+export namespace CreatePermissionCommand {
+  export const getUrl = PERMISSIONS_API.create;
+  export const endpoint = PERMISSIONS_CONTROLLER.endpoints.create;
+  export const httpMethod = HTTP_METHOD.post;
+
+  export const RequestSchema = CreatePermissionCommandRequestSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = PermissionSchema;
+  export type Response = z.infer<typeof ResponseSchema>;
+}

package/permissions/commands/delete-permission.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { HTTP_METHOD } from '../../common';
+import { PermissionSchema } from '../permission.model';
+import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
+
+export namespace DeletePermissionCommand {
+  export const getUrl = PERMISSIONS_API.delete;
+  export const endpoint = PERMISSIONS_CONTROLLER.endpoints.delete;
+  export const httpMethod = HTTP_METHOD.delete;
+
+  export const ResponseSchema = PermissionSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/permissions/commands/index.ts

@@ -0,0 +1,3 @@
+export * from './create-permission.command';
+export * from './delete-permission.command';
+export * from './update-permission.command';

package/permissions/commands/update-permission.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { HTTP_METHOD } from '../../common';
+import { PermissionSchema } from '../permission.model';
+import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
+import { CreatePermissionCommand } from './create-permission.command';
+
+export namespace UpdatePermissionCommand {
+  export const getUrl = PERMISSIONS_API.update;
+  export const endpoint = PERMISSIONS_CONTROLLER.endpoints.update;
+  export const httpMethod = HTTP_METHOD.patch;
+
+  export const RequestSchema = CreatePermissionCommand.RequestSchema.partial();
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = PermissionSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/permissions/index.ts

@@ -0,0 +1,4 @@
+export * from './permission.model';
+export * from './permissions.api';
+export * from './commands';
+export * from './queries';

package/permissions/permission.model.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { AppAbility, TimestampSchema } from '../common';
+
+export const PermissionSchema = z
+  .object({
+    id: z.number().positive(),
+    name: z.string().trim().min(1).max(50),
+    action: z.nativeEnum(AppAbility.ACTION),
+    subject: z.nativeEnum(AppAbility.SUBJECT),
+    conditions: z.unknown().optional().nullable(),
+  })
+  .merge(TimestampSchema);
+export type TPermission = z.infer<typeof PermissionSchema>;

package/permissions/permissions.api.ts

@@ -0,0 +1,14 @@
+import { createApi, TController } from '../common/utils';
+
+export const PERMISSIONS_CONTROLLER = {
+  prefix: 'permissions',
+  endpoints: {
+    find: ':id',
+    findMany: '',
+    create: '',
+    update: ':id',
+    delete: ':id',
+  },
+} as const satisfies TController;
+
+export const PERMISSIONS_API = createApi(PERMISSIONS_CONTROLLER);

package/permissions/queries/find-many-permission.query.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { HTTP_METHOD, OrderSchema, PaginationSchema, SearchSchema } from '../../common';
+import { PermissionSchema } from '../permission.model';
+import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
+
+const BaseQuerySchema = PermissionSchema.pick({
+  subject: true,
+  action: true,
+}).partial();
+const OrderBySchema = PermissionSchema.pick({
+  name: true,
+  subject: true,
+})
+  .keyof()
+  .optional();
+const FindManyPermissionsQueryRequestSchema = BaseQuerySchema.extend({ orderBy: OrderBySchema })
+  .merge(OrderSchema)
+  .merge(SearchSchema);
+
+const FindManyPermissionsQueryResponseSchema = z
+  .object({
+    permissions: z.array(PermissionSchema),
+  })
+  .merge(PaginationSchema);
+
+export namespace FindManyPermissionsQuery {
+  export const getUrl = PERMISSIONS_API.findMany;
+  export const endpoint = PERMISSIONS_CONTROLLER.endpoints.findMany;
+  export const httpMethod = HTTP_METHOD.get;
+
+  export const RequestSchema = FindManyPermissionsQueryRequestSchema;
+  export type TRequest = z.infer<typeof RequestSchema>;
+
+  export const ResponseSchema = FindManyPermissionsQueryResponseSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/permissions/queries/find-permission.query.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { HTTP_METHOD } from '../../common';
+import { PermissionSchema } from '../permission.model';
+import { PERMISSIONS_API, PERMISSIONS_CONTROLLER } from '../permissions.api';
+
+export namespace FindPermissionQuery {
+  export const getUrl = PERMISSIONS_API.find;
+  export const endpoint = PERMISSIONS_CONTROLLER.endpoints.find;
+  export const httpMethod = HTTP_METHOD.get;
+
+  export const ResponseSchema = PermissionSchema;
+  export type TResponse = z.infer<typeof ResponseSchema>;
+}

package/permissions/queries/index.ts

@@ -0,0 +1,2 @@
+export * from './find-many-permission.query';
+export * from './find-permission.query';