@x-fiber-sys/be-common 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# `be-common`
+
+> TODO: description
+
+## Usage
+
+```
+const beCommon = require('be-common');
+
+// TODO: DEMONSTRATE API
+```

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@x-fiber-sys/be-common",
+  "version": "0.1.0",
+  "description": "Package with common c-argo-be information's - schemas, decorators, etc.",
+  "author": "pestsov-v <pestsov.js@gmail.com>",
+  "homepage": "https://github.com/pestsov-v/c-argo-back-mono#readme",
+  "license": "ISC",
+  "main": "src/index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pestsov-v/c-argo-back-mono.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pestsov-v/c-argo-back-mono/issues"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.41"
+  }
+}

package/src/audit/index.ts

@@ -0,0 +1 @@
+export * from './users-actions'

package/src/audit/users-actions.ts

@@ -0,0 +1,12 @@
+import { revertObject } from '../utils'
+
+export const UsersActionMapping = {
+  user_signin: 1,
+  user_signup: 2,
+  user_logout: 3,
+} as const
+
+export const UsersActionReverted = revertObject(UsersActionMapping)
+
+export type UsersActionKey = keyof typeof UsersActionMapping
+export type UsersAction = (typeof UsersActionMapping)[UsersActionKey]

package/src/constants/account-kind.ts

@@ -0,0 +1,11 @@
+import { revertObject } from '../utils'
+
+export const AccountKindMapping = {
+  organisation: 1,
+  personal: 2,
+} as const
+
+export type AccountKindKey = keyof typeof AccountKindMapping
+export type AccountKind = (typeof AccountKindMapping)[AccountKindKey]
+
+export const AccountKindReverted = revertObject(AccountKindMapping)

package/src/constants/common-headers.ts

@@ -0,0 +1,32 @@
+export const UserHeaders = {
+  X_ORGANISATION_ID: 'x-c-argo-organisation-id',
+  X_USER_ID: 'x-c-argo-user-id',
+  X_USER_NAME: 'x-c-argo-user-name',
+  X_DEVICE_ID: 'x-c-argo-device-id',
+  X_ROLE_IDS: 'x-c-argo-role-ids',
+  X_SUBDIVISIONS_IDS: 'x-c-argo-subdivisions-ids',
+  X_SESSION_ID: 'x-c-argo-session-id',
+  X_ACCOUNT_KIND: 'x-c-argo-account-kind',
+  X_SESSION_KIND: 'x-c-argo-session-kind',
+  X_ECOSYSTEM_DOMAIN: 'x-c-argo-ecosystem-domain',
+  X_ORIGIN_IP: 'x-c-argo-origin-ip',
+  X_ORIGIN_USER_AGENT: 'x-c-argo-user-agent',
+  X_SERVICE_NAME: 'x-c-argo-service-name',
+} as const
+
+export const TraceHeaders = {
+  X_TRACE_ID: 'x-c-argo-trace-id',
+  X_CARRIER_PAYLOAD: 'x-c-argo-carrier-payload',
+} as const
+
+export const AuthHeaders = {
+  X_ACCESS_TOKEN: 'x-c-argo-access-token',
+  X_REFRESH_TOKEN: 'x-c-argo-refresh-token',
+} as const
+
+export const ManagerHeaders = {
+  X_MANAGER_SERVICE_NAME: 'x-c-argo-manager-service-name',
+  X_MANAGER_USER_ID: 'x-c-argo-manager-user-id',
+  X_MANAGER_USER_NAME: 'x-c-argo-manager-user-name',
+  X_MANAGER_USER_PASSWORD: 'x-c-argo-user-password',
+} as const

package/src/constants/ecosystem-kind.ts

@@ -0,0 +1,12 @@
+import { revertObject } from '../utils'
+
+export const EcosystemKindMapping = {
+  ERP: 1,
+  market: 2,
+  exchange: 3,
+} as const
+
+export const EcosystemKindReverted = revertObject(EcosystemKindMapping)
+
+export type EcosystemKindKey = keyof typeof EcosystemKindMapping
+export type EcosystemKind = (typeof EcosystemKindMapping)[EcosystemKindKey]

package/src/constants/index.ts

@@ -0,0 +1,8 @@
+export * from './common-headers'
+export * from './account-kind'
+export * from './ecosystem-kind'
+export * from './protocol-kind'
+export * from './trace-tags'
+export * from './session-kind'
+export * from './services-list'
+export * from './kafka-headers'

package/src/constants/kafka-headers.ts

@@ -0,0 +1,17 @@
+import { revertObject } from '../utils'
+
+export const KafkaHeadersMapping = {
+  X_BUTCH_SIZE: 'x-sys-kafka-butch-size',
+  X_BUTCH_KIND: 'x-sys-kafka-butch-kind',
+  X_BUTCH_LAST_ITEM_INDEX: 'x-sys-kafka-last-item-index',
+  X_BUTCH_FIRST_ITEM_INDEX: 'x-sys-kafka-first-item-index',
+
+  X_BUTCH_CHUNK_GROUP_ID: 'x-sys-kafka-butch-group-id',
+  X_BUTCH_CHUNK_INDEX: 'x-sys-kafka-butch-chunk-index',
+  X_BUTCH_LAST_CHUNK_INDEX: 'x-sys-kafka-butch-last-chunk-index',
+} as const
+
+export const KafkaHeadersReverted = revertObject(KafkaHeadersMapping)
+
+export type KafkaHeadersKey = keyof typeof KafkaHeadersMapping
+export type KafkaHeaders = (typeof KafkaHeadersMapping)[KafkaHeadersKey]

package/src/constants/protocol-kind.ts

@@ -0,0 +1,12 @@
+import { revertObject } from '../utils'
+
+export const ProtocolKindMapping = {
+  http: 1,
+  mq: 2,
+  ws: 3,
+} as const
+
+export const ProtocolKindReverted = revertObject(ProtocolKindMapping)
+
+export type ProtocolKindKey = keyof typeof ProtocolKindMapping
+export type ProtocolKind = (typeof ProtocolKindMapping)[ProtocolKindKey]

package/src/constants/services-list.ts

@@ -0,0 +1,18 @@
+import { revertObject } from '../utils'
+
+export const ServiceListUrls = {
+  // sys
+  'alerts-service': 'ALERTS_SERVICE_URL',
+  'api-gw-service': 'API_GW_SERVICE_URL',
+  'toggle-service': 'TOGGLE_SERVICE_URL',
+  'jobs-service': 'JOBS_SERVICE_URL',
+  'manager-service': 'MANAGER_SERVICE_URL',
+
+  // business
+  'users-service': 'USERS_SERVICE_URL',
+} as const
+
+export const ServiceListUrlsReverted = revertObject(ServiceListUrls)
+
+export type ServiceListUrlsKey = keyof typeof ServiceListUrls
+export type ServiceListUrls = (typeof ServiceListUrls)[ServiceListUrlsKey]

package/src/constants/session-kind.ts

@@ -0,0 +1,13 @@
+import { revertObject } from '../utils'
+
+export const SessionKindMapping = {
+  jobs: 'J',
+  sys: 'S',
+  user: 'U',
+  device: 'D',
+} as const
+
+export type SessionKindKey = keyof typeof SessionKindMapping
+export type SessionKind = (typeof SessionKindMapping)[SessionKindKey]
+
+export const SessionKindReverted = revertObject(SessionKindMapping)

package/src/constants/trace-tags.ts

@@ -0,0 +1,28 @@
+export const DefaultTraceTags = {
+  // user
+  user_id: 'user.id',
+  user_organisation_id: 'user.organisation_id',
+  user_session_id: 'user.session_id',
+  role_ids: 'user.role_ids',
+  account_kind: 'user.user_account_kind',
+
+  // device
+  device_id: 'device.device_id',
+  device_session_id: 'device.session_id',
+  device_organisation_id: 'device.organisation_id',
+
+  // request
+  request_id: 'request.request_id',
+  request_ip: 'request.ip',
+  origin_ip: 'request.origin_ip',
+
+  // sys
+  sys_user_id: 'sys.user_id',
+  sys_service_name: 'sys.service_name',
+
+  // action
+  action_kind: 'action.kind',
+  action_protocol: 'action.protocol',
+  action_version: 'action.version',
+  action_method: 'action.method',
+} as const

package/src/errors/index.ts

@@ -0,0 +1,120 @@
+export type ErrorKind =
+  | 'BadRequest'
+  | 'Conflict'
+  | 'Forbidden'
+  | 'Unauthorized'
+  | 'NotFound'
+  | 'Internal'
+
+export type ErrorLayer = 'system' | 'business'
+
+export type AppErrorOptions<TMeta = object> = {
+  type: ErrorKind
+  statusCode?: number
+  message?: string
+  layer: ErrorLayer
+  origin?: Error
+  meta?: TMeta
+}
+
+export type AppSpecificErrorOptions<TMeta = object> = Omit<AppErrorOptions<TMeta>, 'type' | 'layer'>
+
+export type ErrorPayload<TMeta = object> = AppErrorOptions<TMeta> & {
+  textCode: string
+}
+
+export class AppError<C extends string, TMeta extends object | undefined = object>
+  extends Error
+  implements AppErrorOptions<TMeta>
+{
+  public readonly textCode: string
+  public readonly statusCode?: number
+  public readonly type: ErrorKind
+  public readonly layer: ErrorLayer
+
+  public readonly origin?: Error
+  public readonly msg?: string
+  public readonly meta?: TMeta
+
+  constructor(textCode: C, options: AppErrorOptions<TMeta>) {
+    super(textCode)
+    this.textCode = textCode
+    this.type = options.type
+    this.layer = options.layer
+    this.statusCode = options.statusCode
+
+    this.name = new.target.name
+    this.msg = options.message
+    this.origin = options.origin
+    this.meta = options.meta
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor)
+    }
+  }
+
+  toJSON(): ErrorPayload<TMeta> {
+    return {
+      textCode: this.textCode,
+      origin: this.origin,
+      type: this.type,
+      message: this.msg,
+      meta: this.meta,
+      layer: this.layer,
+    }
+  }
+}
+
+export class BadRequest<
+  C extends string = string,
+  TMeta extends object | undefined = object,
+> extends AppError<C, TMeta> {
+  constructor(textCode: C, options?: AppSpecificErrorOptions<TMeta>) {
+    super(textCode, { type: 'BadRequest', layer: 'business', ...options })
+  }
+}
+
+export class Conflict<
+  C extends string = string,
+  TMeta extends object | undefined = object,
+> extends AppError<C, TMeta> {
+  constructor(textCode: C, options?: AppSpecificErrorOptions<TMeta>) {
+    super(textCode, { type: 'Conflict', layer: 'business', ...options })
+  }
+}
+
+export class Forbidden<
+  C extends string = string,
+  TMeta extends object | undefined = object,
+> extends AppError<C, TMeta> {
+  constructor(textCode: C, options?: AppSpecificErrorOptions<TMeta>) {
+    super(textCode, { type: 'Forbidden', layer: 'business', ...options })
+  }
+}
+
+export class Unauthorized<
+  C extends string = string,
+  TMeta extends object | undefined = object,
+> extends AppError<C, TMeta> {
+  constructor(textCode: C, options?: AppSpecificErrorOptions<TMeta>) {
+    super(textCode, { type: 'Unauthorized', layer: 'business', ...options })
+  }
+}
+
+export class NotFound<
+  C extends string = string,
+  TMeta extends object | undefined = object,
+> extends AppError<C, TMeta> {
+  constructor(textCode: C, options?: AppSpecificErrorOptions<TMeta>) {
+    super(textCode, { type: 'NotFound', layer: 'business', ...options })
+  }
+}
+
+export class Internal<
+  C extends string = string,
+  TMeta extends object | undefined = object,
+> extends AppError<C, TMeta> {
+  constructor(textCode: C, options?: AppSpecificErrorOptions<TMeta>) {
+    super(textCode, { type: 'Internal', layer: 'business', ...options })
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './constants'
+export * from './audit'
+export * from './utils'
+export * from './errors'
+export * from './schemas'
+
+export type * from './types'

package/src/schemas/index.ts

@@ -0,0 +1 @@
+export * from './union-schema'

package/src/schemas/union-schema.ts

@@ -0,0 +1,47 @@
+import { TLiteral, Type } from '@sinclair/typebox'
+import { UserHeaders } from '../constants'
+
+import type { TSchema, TUnion, Static } from '@sinclair/typebox'
+
+export const UnionSchema = <T extends Record<string, string | number | symbol>>(
+  obj: T,
+): TSchema => {
+  const literals = (Object.keys(obj) as Array<keyof T>).map((k) => Type.Literal(k as string))
+  return Type.Union(literals)
+}
+
+export const Nullable = <T extends TSchema>(
+  schema: T,
+): TUnion<[ReturnType<typeof Type.Null>, T]> => {
+  return Type.Union([Type.Null(), schema])
+}
+
+export const LiteralUnion = <
+  TObject extends Record<string, any>,
+  TKey extends keyof TObject & string,
+>(
+  obj: TObject,
+): TUnion<[TLiteral<TKey>, ...TLiteral<TKey>[]]> => {
+  const keys = Object.keys(obj) as TKey[]
+
+  const literals = keys.map((key) => Type.Literal(key))
+
+  return Type.Union(literals as [TLiteral<TKey>, ...TLiteral<TKey>[]])
+}
+
+export const DateSchema = Type.Unsafe<Date>({ type: 'string', format: 'date-time' })
+
+export const UserAuthHeadersSchema = Type.Object({
+  [UserHeaders.X_ORGANISATION_ID]: Type.String(),
+  [UserHeaders.X_USER_ID]: Type.String(),
+  [UserHeaders.X_SESSION_ID]: Type.String(),
+  [UserHeaders.X_ACCOUNT_KIND]: Type.Union([
+    Type.Literal('personal'),
+    Type.Literal('organisation'),
+  ]),
+  [UserHeaders.X_ECOSYSTEM_DOMAIN]: Type.Union([Type.Literal('ERP')]),
+  [UserHeaders.X_ORIGIN_IP]: Type.String(),
+  [UserHeaders.X_ROLE_IDS]: Type.Union([Type.String(), Type.Null()]),
+})
+
+export type UserAuthHeaders = Static<typeof UserAuthHeadersSchema>

package/src/types/fastify.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyReply, FastifySchema } from 'fastify'
+
+export { FastifySchema, FastifyReply }

package/src/types/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './jwt-payloads'
+export type * from './fastify'
+export type * from './transport'
+export type * from './protocol'
+export type * from './repository'
+
+export type Class<T = any, R = any> = new (...args: T[]) => R

package/src/types/jwt-payloads.d.ts

@@ -0,0 +1,18 @@
+import type { AccountKindKey, EcosystemKindKey, SessionKindKey } from '../constants'
+
+export interface JwtRefreshPayload {
+  sessionId: string
+  version: number
+}
+
+export interface JwtAccessPayload extends JwtRefreshPayload {
+  user_id: string
+  session_id: string
+  account_kind: AccountKindKey
+  session_kind: SessionKindKey
+  ecosystem_kind: EcosystemKindKey
+  organisation_id: string
+  subdivisions_ids: string[] | null
+  role_ids: string[]
+  expired_at: string
+}

package/src/types/protocol.d.ts

@@ -0,0 +1,2 @@
+export type ApiVersion = 'v1' | 'v2' | 'v3' | 'v4' | 'v5'
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD'

package/src/types/repository.d.ts

@@ -0,0 +1 @@
+export type ContainKind = 'include' | 'exclude'

package/src/types/transport.d.ts

@@ -0,0 +1,2 @@
+export type TransportProtocol = 'http' | 'ws' | 'kafka'
+export type AccessScope = 'private' | 'public' | 'hybrid'

package/src/utils/chunk-generator.ts

@@ -0,0 +1,5 @@
+export function* chunkGenerator<TItem>(arr: TItem[], chunkSize: number): Generator<TItem[], void> {
+  for (let i = 0; i < arr.length; i += chunkSize) {
+    yield arr.slice(i, i + chunkSize)
+  }
+}

package/src/utils/create-object-enum.ts

@@ -0,0 +1,9 @@
+import { DatasetEnumItem } from '@x-fiber-sys/contract'
+
+export const createObjectEnum = <T extends Record<string, number>, K extends keyof T>(
+  object: T,
+): DatasetEnumItem<T, K>[] => {
+  return Object.entries(object).map(([k, v]) => {
+    return { key: k, value: v }
+  }) as DatasetEnumItem<T, K>[]
+}

package/src/utils/create-symbols.ts

@@ -0,0 +1,8 @@
+export const createSymbols = <const T extends readonly string[]>(
+    ...keys: T
+): { [K in T[number]]: symbol } => {
+    return keys.reduce((acc, key) => {
+        (acc as any)[key] = Symbol.for(key)
+        return acc
+    }, {} as { [K in T[number]]: symbol })
+}

package/src/utils/get-strictness-fields.ts

@@ -0,0 +1,12 @@
+export const getStrictnessFields = <T = object>(fields: T): Partial<T> => {
+  const updatedFields: Partial<T> = {}
+
+  for (const key in fields) {
+    const val = fields[key]
+    if (val !== undefined && val !== null) {
+      updatedFields[key] = val
+    }
+  }
+
+  return updatedFields
+}

package/src/utils/get-stringify-header.ts

@@ -0,0 +1,6 @@
+export const getStringifyHeader = (
+  headers: Record<string, string | string[] | undefined>,
+  key: string,
+): string | undefined => {
+  return headers[key] as string | undefined
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './chunk-generator'
+export * from './create-symbols'
+export * from './revert-object'
+export * from './get-strictness-fields'
+export * from './get-stringify-header'
+export * from './create-object-enum'

package/src/utils/revert-object.ts

@@ -0,0 +1,12 @@
+export type Reverted<T extends Record<string, number | string>> = {
+    [K in keyof T as T[K]]: K
+}
+
+export const revertObject = <TObject extends Record<string, number | string>>(object: TObject) =>
+    Object.entries(object).reduce<Reverted<TObject>>(
+        (prev, [key, value]) => ({
+            ...prev,
+            [value]: key,
+        }),
+        {} as Reverted<TObject>,
+    )