@erxes/api-shared 0.0.0-stage → 3.2.19-1

package/package.json

@@ -1,6 +1,107 @@
 {
   "name": "@erxes/api-shared",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.2.19-1",
+  "description": "Shared platform utilities for erxes backend plugins: plugin startup, tenant-scoped models, service discovery, messaging and core types.",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/erxes/erxes.git",
+    "directory": "backend/erxes-api-shared"
+  },
+  "main": "dist/erxes-api-shared.cjs.js",
+  "module": "dist/erxes-api-shared.esm.js",
+  "types": "dist/erxes-api-shared.cjs.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/erxes-api-shared.cjs.d.ts",
+      "import": "./dist/erxes-api-shared.esm.js",
+      "require": "./dist/erxes-api-shared.cjs.js",
+      "default": "./dist/erxes-api-shared.cjs.js"
+    },
+    "./utils": {
+      "types": "./utils/dist/erxes-api-shared-utils.cjs.d.ts",
+      "import": "./utils/dist/erxes-api-shared-utils.esm.js",
+      "require": "./utils/dist/erxes-api-shared-utils.cjs.js",
+      "default": "./utils/dist/erxes-api-shared-utils.cjs.js"
+    },
+    "./core-types": {
+      "types": "./core-types/dist/erxes-api-shared-core-types.cjs.d.ts",
+      "import": "./core-types/dist/erxes-api-shared-core-types.esm.js",
+      "require": "./core-types/dist/erxes-api-shared-core-types.cjs.js",
+      "default": "./core-types/dist/erxes-api-shared-core-types.cjs.js"
+    },
+    "./core-modules": {
+      "types": "./core-modules/dist/erxes-api-shared-core-modules.cjs.d.ts",
+      "import": "./core-modules/dist/erxes-api-shared-core-modules.esm.js",
+      "require": "./core-modules/dist/erxes-api-shared-core-modules.cjs.js",
+      "default": "./core-modules/dist/erxes-api-shared-core-modules.cjs.js"
+    },
+    "./src": "./src/index.ts",
+    "./src/*": [
+      "./src/*.ts",
+      "./src/*/index.ts"
+    ],
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "pnpm": ">=8",
+    "npm": "please-use-pnpm",
+    "yarn": "please-use-pnpm"
+  },
+  "dependencies": {
+    "@apollo/server": "^4.11.3",
+    "@apollo/subgraph": "^2.9.3",
+    "@azure/storage-blob": "^12.29.1",
+    "@google-cloud/storage": "^7.17.3",
+    "@sendgrid/mail": "^8.1.5",
+    "@sentry/node": "^10.55.0",
+    "@sniptt/guards": "^0.2.0",
+    "@trpc/client": "^11.0.0",
+    "@trpc/server": "^11.0.0",
+    "aws-sdk": "^2.1692.0",
+    "bullmq": "^5.40.0",
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "csv-parse": "^6.2.1",
+    "dataloader": "^2.2.3",
+    "dayjs": "^1.11.13",
+    "dotenv": "^16.4.7",
+    "exceljs": "^4.4.0",
+    "express": "^4.21.2",
+    "express-rate-limit": "^8.0.1",
+    "file-type": "^20.5.0",
+    "form-data": "^4.0.2",
+    "graphql": "^16.9.0",
+    "graphql-redis-subscriptions": "^2.7.0",
+    "graphql-subscriptions": "^3.0.0",
+    "ioredis": "^5.6.1",
+    "lodash": "^4.17.21",
+    "moment": "^2.30.1",
+    "mongoose": "^8.10.0",
+    "nanoid": "^3.3.6",
+    "node-fetch": "^2.6.7",
+    "nodemailer": "^6.9.10",
+    "strip-ansi": "^6.0.1",
+    "tslib": "^2.3.0",
+    "zod": "3.23.8"
+  },
+  "preconstruct": {
+    "tsconfig": "tsconfig.lib.json",
+    "entrypoints": [
+      "./index.ts",
+      "./utils/index.ts",
+      "./core-types/index.ts",
+      "./core-modules/index.ts"
+    ]
+  },
+  "files": [
+    "dist",
+    "core-types",
+    "utils",
+    "core-modules",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/common-modules/payment/worker.ts

@@ -0,0 +1,53 @@
+import {
+  createMQWorkerWithListeners,
+  initializePluginConfig,
+  redis
+} from '../../utils';
+
+
+export const startPayments = async (
+  pluginName: string,
+  config: any,
+) => {
+  await initializePluginConfig(pluginName, 'payments', config);
+
+  return new Promise<void>((resolve, reject) => {
+    try {
+      createMQWorkerWithListeners(
+        pluginName,
+        'payments',
+        async ({ name, id, data: jobData }) => {
+          try {
+            const { subdomain, data } = jobData;
+
+            if (!subdomain) {
+              throw new Error('You should provide subdomain on message');
+            }
+
+            const resolverName = name as keyof any;
+
+            if (
+              !(name in config) ||
+              typeof config[resolverName] !== 'function'
+            ) {
+              throw new Error(`Payments method ${name} not registered`);
+            }
+
+            const resolver = config[resolverName];
+
+            return await resolver({ subdomain }, data);
+          } catch (error: any) {
+            console.error(`Error processing job ${id}: ${error.message}`);
+            throw error;
+          }
+        },
+        redis,
+        () => {
+          resolve();
+        },
+      );
+    } catch (error) {
+      reject(error);
+    }
+  });
+};

package/src/core-modules/approval/approvalChangeTypes.ts

@@ -0,0 +1,31 @@
+import { TApprovalConfig } from './types';
+
+/**
+ * A change type is `<plugin>:<what>`, so the prefix alone says who carries it
+ * out — the same routing the rest of the platform uses for record references.
+ */
+export const approvalChangePluginName = (changeType: string) =>
+  (changeType || '').split(':')[0];
+
+export const normalizeApprovalChangeType = (
+  pluginName: string,
+  changeType: string,
+) => (changeType.includes(':') ? changeType : `${pluginName}:${changeType}`);
+
+export const localApprovalChangeType = (
+  pluginName: string,
+  changeType: string,
+) =>
+  changeType.startsWith(`${pluginName}:`)
+    ? changeType.slice(pluginName.length + 1)
+    : changeType;
+
+export const normalizeApprovalConfig = (
+  pluginName: string,
+  config: TApprovalConfig,
+) => ({
+  changeTypes: (config.changeTypes || []).map((changeType) => ({
+    ...changeType,
+    type: normalizeApprovalChangeType(pluginName, changeType.type),
+  })),
+});

package/src/core-modules/approval/checkApprovalLock.ts

@@ -0,0 +1,85 @@
+import { ExpectedError, sendTRPCMessage } from '../../utils';
+import {
+  ApprovalLockAssertResponse,
+  ApprovalLockState,
+  ApprovalRemoteLockCheckInput,
+  ApprovalRemoteLockStatesInput,
+} from './types';
+
+const unavailableState = (
+  input: Pick<
+    ApprovalRemoteLockCheckInput,
+    'contentType' | 'contentId' | 'action'
+  >,
+): ApprovalLockState => ({
+  contentType: input.contentType,
+  contentId: input.contentId,
+  action: input.action,
+  locked: true,
+  hasAccess: false,
+  reason: 'Approval lock check unavailable',
+});
+
+export const checkApprovalLock = {
+  async state(input: ApprovalRemoteLockCheckInput): Promise<ApprovalLockState> {
+    return (await sendTRPCMessage({
+      subdomain: input.subdomain,
+      pluginName: 'core',
+      method: 'query',
+      module: 'approval',
+      action: 'state',
+      input,
+      context: { userId: input.userId },
+      defaultValue: unavailableState(input),
+    })) as ApprovalLockState;
+  },
+
+  async states(
+    input: ApprovalRemoteLockStatesInput,
+  ): Promise<ApprovalLockState[]> {
+    const defaultValue = input.contentIds.map((contentId) =>
+      unavailableState({
+        contentType: input.contentType,
+        contentId,
+        action: input.action,
+      }),
+    );
+
+    return (await sendTRPCMessage({
+      subdomain: input.subdomain,
+      pluginName: 'core',
+      method: 'query',
+      module: 'approval',
+      action: 'states',
+      input,
+      context: { userId: input.userId },
+      defaultValue,
+    })) as ApprovalLockState[];
+  },
+
+  async assert(
+    input: ApprovalRemoteLockCheckInput,
+  ): Promise<ApprovalLockState> {
+    const defaultState = unavailableState(input);
+    const result = (await sendTRPCMessage({
+      subdomain: input.subdomain,
+      pluginName: 'core',
+      method: 'mutation',
+      module: 'approval',
+      action: 'assert',
+      input,
+      context: { userId: input.userId },
+      defaultValue: {
+        allowed: false,
+        message: defaultState.reason,
+        state: defaultState,
+      },
+    })) as ApprovalLockAssertResponse;
+
+    if (!result.allowed) {
+      throw new ExpectedError(result.message || 'Locked', 'FORBIDDEN');
+    }
+
+    return result.state;
+  },
+};

package/src/core-modules/approval/constants.ts

@@ -0,0 +1,45 @@
+export const APPROVAL_LOCK_STATUSES = {
+  ACTIVE: 'active',
+  RELEASED: 'released',
+} as const;
+
+export const APPROVAL_APPROVER_SCOPES = {
+  LOCKER_ONLY: 'lockerOnly',
+  LOCKER_AND_ALLOWED_USERS: 'lockerAndAllowedUsers',
+} as const;
+
+export const APPROVAL_MODES = {
+  FIRST_WINS: 'firstWins',
+  UNANIMOUS: 'unanimous',
+} as const;
+
+export const APPROVAL_REQUEST_STATUSES = {
+  PENDING: 'pending',
+  APPROVED: 'approved',
+  REJECTED: 'rejected',
+  CANCELLED: 'cancelled',
+  // Approved, but the change it carried could not be applied. Kept apart from
+  // `approved` so a decision nobody acted on is never read as a done one.
+  APPLY_FAILED: 'applyFailed',
+} as const;
+
+/**
+ * What a request asks for. `access` lets the requester past a lock and the
+ * system does nothing else; `change` carries the work itself, and approving it
+ * is what performs it.
+ */
+export const APPROVAL_REQUEST_KINDS = {
+  ACCESS: 'access',
+  CHANGE: 'change',
+} as const;
+
+export const APPROVAL_DECISIONS = {
+  APPROVED: 'approved',
+  REJECTED: 'rejected',
+} as const;
+
+export const APPROVAL_NOTIFICATION_CONTENT_TYPE = 'core:approval';
+
+export const APPROVAL_NOTIFICATION_ACTIONS = {
+  REQUESTED: 'approval.requested',
+} as const;

package/src/core-modules/approval/index.ts

@@ -0,0 +1,6 @@
+export * from './approvalChangeTypes';
+export * from './checkApprovalLock';
+export * from './initApproval';
+export * from './constants';
+export * from './types';
+export * from './zodSchemas';

package/src/core-modules/approval/initApproval.ts

@@ -0,0 +1,59 @@
+import { AnyProcedure, initTRPC } from '@trpc/server';
+import * as trpcExpress from '@trpc/server/adapters/express';
+import { Express } from 'express';
+import { initializePluginConfig } from '../../utils/service-discovery';
+import { createTRPCContext } from '../../utils/trpc';
+import { TApprovalChangeProducers, TApprovalConfig } from './types';
+import { approvalChangeApplyInputSchema } from './zodSchemas';
+import {
+  localApprovalChangeType,
+  normalizeApprovalConfig,
+} from './approvalChangeTypes';
+
+/**
+ * Puts a plugin's approved-change work on the wire: the change types it owns
+ * are declared to service discovery, and approval reaches the applier through
+ * this endpoint instead of anything registered inside core's own process.
+ */
+export const initApproval = async (
+  app: Express,
+  pluginName: string,
+  config: TApprovalConfig,
+) => {
+  await initializePluginConfig(
+    pluginName,
+    'approval',
+    normalizeApprovalConfig(pluginName, config),
+  );
+
+  const t = initTRPC.context<any>().create();
+  const procedures: Record<string, AnyProcedure> = {
+    [TApprovalChangeProducers.APPLY]: t.procedure
+      .input(approvalChangeApplyInputSchema)
+      .mutation(async ({ input }) => {
+        const { subdomain, data } = input;
+        const applier =
+          config.appliers[localApprovalChangeType(pluginName, data.changeType)];
+
+        if (!applier) {
+          throw new Error(
+            `${pluginName} does not apply "${data.changeType}"`,
+          );
+        }
+
+        const models = await config.generateModels(subdomain);
+
+        await applier({ ...data, models, subdomain });
+
+        return { applied: true };
+      }),
+  };
+
+  app.use(
+    '/approval',
+    trpcExpress.createExpressMiddleware({
+      router: t.router(procedures),
+      createContext: createTRPCContext(async (_subdomain, context) => context),
+    }),
+  );
+};

package/src/core-modules/approval/types.ts

@@ -0,0 +1,206 @@
+import {
+  APPROVAL_APPROVER_SCOPES,
+  APPROVAL_DECISIONS,
+  APPROVAL_LOCK_STATUSES,
+  APPROVAL_MODES,
+  APPROVAL_REQUEST_KINDS,
+  APPROVAL_REQUEST_STATUSES,
+} from './constants';
+
+export type ApprovalLockStatus =
+  (typeof APPROVAL_LOCK_STATUSES)[keyof typeof APPROVAL_LOCK_STATUSES];
+
+export type ApprovalApproverScope =
+  (typeof APPROVAL_APPROVER_SCOPES)[keyof typeof APPROVAL_APPROVER_SCOPES];
+
+export type ApprovalMode = (typeof APPROVAL_MODES)[keyof typeof APPROVAL_MODES];
+
+export type ApprovalRequestStatus =
+  (typeof APPROVAL_REQUEST_STATUSES)[keyof typeof APPROVAL_REQUEST_STATUSES];
+
+export type ApprovalRequestKind =
+  (typeof APPROVAL_REQUEST_KINDS)[keyof typeof APPROVAL_REQUEST_KINDS];
+
+export type ApprovalDecisionValue =
+  (typeof APPROVAL_DECISIONS)[keyof typeof APPROVAL_DECISIONS];
+
+export type ApprovalAction = 'view' | 'edit' | 'delete' | 'toggle' | string;
+
+export type ApprovalDecision = {
+  userId: string;
+  decision: ApprovalDecisionValue;
+  reason?: string;
+  at: Date;
+};
+
+export type ApprovalLock = {
+  _id: string;
+  contentType: string;
+  contentId: string;
+  lockedBy: string;
+  ownerIdSnapshot?: string;
+  allowedUserIds: string[];
+  approverScope: ApprovalApproverScope;
+  approvalMode: ApprovalMode;
+  status: ApprovalLockStatus;
+  createdAt: Date;
+  releasedAt?: Date;
+  releasedBy?: string;
+  releaseReason?: string;
+};
+
+/**
+ * The work a change request carries. The document says what kind of change it
+ * is; the code registers how to apply that kind, so approval never has to know
+ * what any module does.
+ */
+export type ApprovalChange = {
+  changeType: string;
+  payload?: Record<string, unknown>;
+  summary: string;
+};
+
+export type ApprovalRequest = {
+  _id: string;
+  kind: ApprovalRequestKind;
+  contentType: string;
+  contentId: string;
+  /** Access requests are always about a lock; change requests need none. */
+  lockId?: string;
+  requesterId: string;
+  reason?: string;
+  status: ApprovalRequestStatus;
+  requiredApproverIds: string[];
+  decisions: ApprovalDecision[];
+  notificationIds?: string[];
+  change?: ApprovalChange;
+  /** When the carried change was performed, and why it was not. */
+  appliedAt?: Date;
+  applyError?: string;
+  createdAt: Date;
+  resolvedAt?: Date;
+};
+
+export type ApprovalContentMeta = {
+  contentType: string;
+  contentId: string;
+  label?: string;
+  ownerId?: string;
+};
+
+export type ApprovalLockState = {
+  contentType: string;
+  contentId: string;
+  action?: ApprovalAction;
+  locked: boolean;
+  hasAccess: boolean;
+  reason?: string;
+  content?: ApprovalContentMeta;
+  lock?: ApprovalLock;
+  pendingRequest?: ApprovalRequest;
+};
+
+export type ApprovalLockCheckInput = {
+  contentType: string;
+  contentId: string;
+  ownerId?: string;
+  action?: ApprovalAction;
+};
+
+export type ApprovalLockStatesInput = {
+  contentType: string;
+  contentIds: string[];
+  ownerIdsByContentId?: Record<string, string>;
+  action?: ApprovalAction;
+};
+
+export type ApprovalRemoteLockCheckInput = ApprovalLockCheckInput & {
+  subdomain: string;
+  userId: string;
+};
+
+export type ApprovalRemoteLockStatesInput = ApprovalLockStatesInput & {
+  subdomain: string;
+  userId: string;
+};
+
+export type ApprovalLockAssertResponse = {
+  allowed: boolean;
+  message?: string;
+  state: ApprovalLockState;
+};
+
+export type ApprovalLockCreateInput = {
+  contentType: string;
+  contentTypeId: string;
+  ownerId: string;
+  allowedUserIds?: string[];
+  scope?: ApprovalApproverScope;
+  mode?: ApprovalMode;
+};
+
+export type ApprovalRequestCreateInput = {
+  contentType: string;
+  contentId: string;
+  reason?: string;
+  /** Present on a change request: what is being proposed. */
+  change?: ApprovalChange;
+  /** Who must agree to it. A change request names its own approvers. */
+  approverIds?: string[];
+};
+
+export type ApprovalNotificationMetadata = {
+  approvalRequestId: string;
+  /** Absent when the request carries a change rather than asking for access. */
+  lockId?: string;
+  targetContentType: string;
+  targetContentId: string;
+  targetLabel?: string;
+};
+
+export enum TApprovalChangeProducers {
+  APPLY = 'applyChange',
+}
+
+/**
+ * Everything the owning plugin needs to carry out an approved change. The
+ * request itself stays with approval; what crosses the wire is the work.
+ */
+export type TApprovalChangeApplyInput = {
+  requestId: string;
+  changeType: string;
+  payload?: Record<string, unknown>;
+  contentType: string;
+  contentId: string;
+  requesterId: string;
+  approverId: string;
+};
+
+export type TApprovalChangeProducersInput = {
+  [TApprovalChangeProducers.APPLY]: TApprovalChangeApplyInput;
+};
+
+export type TApprovalChangeApplierProps<TModels = any> =
+  TApprovalChangeApplyInput & {
+    models: TModels;
+    subdomain: string;
+  };
+
+export type TApprovalChangeApplier<TModels = any> = (
+  props: TApprovalChangeApplierProps<TModels>,
+) => Promise<void>;
+
+export type TApprovalChangeType = {
+  type: string;
+  label: string;
+};
+
+/**
+ * A plugin declares the changes it can carry out and how. Approval then knows
+ * only that someone owns a change type — never what that change does.
+ */
+export type TApprovalConfig<TModels = any> = {
+  changeTypes: TApprovalChangeType[];
+  appliers: Record<string, TApprovalChangeApplier<TModels>>;
+  generateModels: (subdomain: string) => Promise<TModels>;
+};

package/src/core-modules/approval/zodSchemas.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { APPROVAL_APPROVER_SCOPES, APPROVAL_MODES } from './constants';
+
+const ownerIdsByContentIdSchema = z.record(z.string(), z.string()).optional();
+
+export const approvalLockCheckInputSchema = z.object({
+  contentType: z.string().min(1),
+  contentId: z.string().min(1),
+  ownerId: z.string().optional(),
+  action: z.string().optional(),
+  userId: z.string().optional(),
+});
+
+export const approvalLockStatesInputSchema = z.object({
+  contentType: z.string().min(1),
+  contentIds: z.array(z.string().min(1)),
+  ownerIdsByContentId: ownerIdsByContentIdSchema,
+  action: z.string().optional(),
+  userId: z.string().optional(),
+});
+
+export const approvalLockCreateInputSchema = z.object({
+  contentType: z.string().min(1),
+  contentTypeId: z.string().min(1),
+  ownerId: z.string().min(1),
+  allowedUserIds: z.array(z.string()).optional(),
+  scope: z
+    .enum([
+      APPROVAL_APPROVER_SCOPES.LOCKER_ONLY,
+      APPROVAL_APPROVER_SCOPES.LOCKER_AND_ALLOWED_USERS,
+    ])
+    .optional(),
+  mode: z
+    .enum([APPROVAL_MODES.FIRST_WINS, APPROVAL_MODES.UNANIMOUS])
+    .optional(),
+});
+
+export const approvalRequestCreateInputSchema = z.object({
+  contentType: z.string().min(1),
+  contentId: z.string().min(1),
+  reason: z.string().optional(),
+});
+
+export const approvalChangeApplyInputSchema = z.object({
+  subdomain: z.string(),
+  data: z.object({
+    requestId: z.string().min(1),
+    changeType: z.string().min(1),
+    payload: z.record(z.string(), z.unknown()).optional(),
+    contentType: z.string().min(1),
+    contentId: z.string().min(1),
+    requesterId: z.string().min(1),
+    approverId: z.string().min(1),
+  }),
+});

package/src/core-modules/apps/@types/app.ts

@@ -0,0 +1,15 @@
+export interface IApp {
+  isEnabled?: boolean;
+  name: string;
+  userGroupId: string;
+  expireDate?: Date;
+  noExpire?: boolean;
+  allowAllPermission?: boolean;
+}
+
+export interface IAppDocument extends IApp, Document {
+  _id: string;
+  createdAt: Date;
+  accessToken: string;
+  refreshToken: string;
+}