@autofleet/zehut 0.0.1-test-gery → 1.0.0-gery-ba-beta-1

package/README.md

@@ -1,45 +1,77 @@
-# AutoFleet Zehut
+# AutoFleet Node Common
+This respostory is made in order have as much of common code as we can.
 
-This package handles authorization and authentication for AutoFleet services.
+Each line of code used in wrriten in this repo will be used in the enetire AutoFleet system.
 
-## Links
+Make sure you have:
+* Tests
+* Docs
 
-See authorization docs [here](./src/user/README.md).
+## Consts
 
-## V4 migration
+Currently we suppurt:
+```
+  {
+    'OK'
+    'ERROR'
+    'FAIL'
+  }
+```
+
+## Network
+Server 2 Servers communication.
+
+Implemented:
+* Retriving service urls from environment
+* Retry - Using https://github.com/softonic/axios-retry
+* Caching - TBD
+* Syntatic response for fail - TBD
+* Circuit Breaking - TBD
 
-### Outbreak v2
-When upgrading from V3 to V4, the tracing system has been de-duped to use outbreak v2.
-Historically, `zehut` and `outbreak` both added a layer of `async_hooks`, which each had a context that could store data.
-The 2 had a nearly identical API, but did not communicate with each other, nor did they share data.
-This version removes the trace added by `zehut` and only uses the `outbreak` one. This means that the context of the trace is now spread onto the headers of any outgoing HTTP request.
-In order to allow keeping data in the context, without having `outbreak` add it to the headers, a new context has been added to the `outbreak` traces - `nonHeaderContext`.
-Using the `getUser` function will keep working regularly, but reading anything else from the context will work only if you read from the correct context.
+The API is just like [axios](https://github.com/axios/axios) api but the creation of new instance **must** have either `serviceName` or `serviceUrl` in options.
 
-```diff
-- const { context } = zehut.getCurrentPayload();
-- const user = context?.get('userObject');
-+ const user = zehut.getUser();
+In case `serviceName` used the constractor will look for an environment varible with the the name `<SERVICE_NAME>_SERVICE_HOST`.
+
+For Example:
 ```
+const { Network } = require('@autofleet/node-common');
+
+n = new Network({ serviceName: 'TEST' });
 
-If you need to read any other data from the context, you should now read and write to `nonHeaderContext`, unless you wish for the values to be sent through to the headers of any outgoing request/response.
-```diff
-const currentTrace = zehut.getCurrentPayload();
--const dataFromContext = currentTrace?.context?.get('DATA_FROM_CONTEXT');
-+const dataFromContext = currentTrace?.nonHeaderContext?.get('DATA_FROM_CONTEXT');
+n.get('/posts/1');
+```
+.env file:
+```
+RIDE_SERVICE_HOST=jsonplaceholder.typicode.com
 ```
 
+To learn more [click here](https://blog.risingstack.com/designing-microservices-architecture-for-failure/).
 
-### Logger
+## Settings
 
-The tracing mechanism has been updated to reduce boilerplate code.
-Now, when calling the `enableTracing` function, you can now pass in the instance of the `logger`, and drop the call for `logger.addContextMiddleware`.
+### Adding settings
+For adding new setting you need to add it to the map.js file, please specify 
+* name - descriptive name
+* description - few words about what it does + unit
+* type - supportable types: 'number', 'string', 'json'
+* defaultValue - default value
+* context - 'security' and 'operation' will not show in the simulator configuration
 
-```diff
--zehut.enableTracing();
--
--logger.addContextMiddleware(() => ({
--  traceId: zehut.outbreak.getCurrentContext()?.context?.get('x-trace-id'),
--}));
-+zehut.enableTracing({ logger });
+See example.
+
+## DeLorean
+
+Use this model to mock time on server - more info TBD.
+
+## Publish package
+
+bump the version number in package.json
+and run
 ```
+npm publish
+```
+
+# Environment Variables 
+
+when using this package locally or outside autofleet-prod project you must set INTEGRATION_MS_SERVICE_HOST in .env file 
+# zehut

package/lib/app-auth.d.ts

@@ -0,0 +1,2 @@
+export declare const decodeAppBearer: (bearer: string, appId: string) => Promise<any>;
+export declare const getClientSecret: (appId: string) => Promise<any>;

package/lib/app-auth.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientSecret = exports.decodeAppBearer = void 0;
+const services_1 = require("./services");
+const decodeAppBearer = async (bearer, appId) => {
+    const { data: decoded } = await services_1.AutofleetApiNetwork.post('/api/v1/auth', { bearer, appId });
+    return decoded;
+};
+exports.decodeAppBearer = decodeAppBearer;
+const getClientSecret = async (appId) => {
+    const { data: secret } = await services_1.AutofleetApiNetwork.get(`/api/v1/auth/client-secret/${appId}`);
+    return secret;
+};
+exports.getClientSecret = getClientSecret;

package/lib/check-permission.d.ts

@@ -0,0 +1,6 @@
+import ApiUser from './user/ApiUser';
+export declare const getUser: () => ApiUser | undefined;
+export declare const isUserExist: () => string;
+export declare const checkFleetPermission: (fleetId: any) => boolean;
+export declare const checkBusinessModelPermission: (businessModelId: any) => boolean;
+export declare const checkDemandSourcePermission: (demandSourceId: any) => boolean;

package/lib/check-permission.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDemandSourcePermission = exports.checkBusinessModelPermission = exports.checkFleetPermission = exports.isUserExist = exports.getUser = void 0;
+const tracer_1 = require("./tracer");
+const getUser = () => (0, tracer_1.getCurrentTrace)()?.context?.get('userObject');
+exports.getUser = getUser;
+const isUserExist = () => {
+    const u = (0, exports.getUser)();
+    return u && u.id;
+};
+exports.isUserExist = isUserExist;
+const checkFleetPermission = (fleetId) => {
+    if ((0, exports.isUserExist)()) {
+        const user = (0, exports.getUser)();
+        return !user || Object.keys(user.permissions.fleets).includes(fleetId);
+    }
+    return true;
+};
+exports.checkFleetPermission = checkFleetPermission;
+const checkBusinessModelPermission = (businessModelId) => {
+    if ((0, exports.isUserExist)()) {
+        const user = (0, exports.getUser)();
+        return !user || Object.keys(user.permissions.businessModels).includes(businessModelId);
+    }
+    return true;
+};
+exports.checkBusinessModelPermission = checkBusinessModelPermission;
+const checkDemandSourcePermission = (demandSourceId) => {
+    if ((0, exports.isUserExist)()) {
+        const user = (0, exports.getUser)();
+        return !user || Object.keys(user.permissions.demandSources).includes(demandSourceId);
+    }
+    return true;
+};
+exports.checkDemandSourcePermission = checkDemandSourcePermission;

package/lib/errors.d.ts

@@ -0,0 +1,5 @@
+import ApiUser from './user';
+export declare class UnauthorizedAccessError extends Error {
+    user: ApiUser;
+    constructor(user?: any, message?: string);
+}

package/lib/errors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthorizedAccessError = void 0;
+// eslint-disable-next-line import/prefer-default-export
+class UnauthorizedAccessError extends Error {
+    constructor(user = null, message = 'UnauthorizedAccessError') {
+        super(message);
+        this.name = 'UnauthorizedAccessError';
+        this.user = user;
+    }
+}
+exports.UnauthorizedAccessError = UnauthorizedAccessError;

package/lib/exceptions/appDoesNotExist.d.ts

@@ -0,0 +1,3 @@
+export default class AppDoesNotExist extends Error {
+    mesaage: 'app does not exist';
+}

package/lib/exceptions/appDoesNotExist.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AppDoesNotExist extends Error {
+}
+exports.default = AppDoesNotExist;

package/lib/index.d.ts

@@ -1,308 +1,50 @@
-import * as outbreak from "@autofleet/outbreak";
-import { newTrace as newTrace$1 } from "@autofleet/outbreak";
-import { LoggerInstanceManager } from "@autofleet/logger";
-import { Handler, NextFunction, Request, Response } from "express";
-import { FastifyPluginCallback } from "fastify";
-
-//#region src/user/ApiUser.d.ts
-type AccountType = "client" | "user" | "service" | "driver";
-type EntityPermissions = Record<string, string[]>;
-declare const CONTEXTS_IDS_HEADER = "x-af-context-ids";
-interface UserExternalData {
-  element?: {
-    internalUser: boolean;
-  };
-  [key: string]: any;
-}
-interface UserPayload {
-  businessModels: EntityPermissions;
-  fleets: EntityPermissions;
-  demandSources: EntityPermissions;
-  businessAccounts?: EntityPermissions;
-  accountType?: AccountType;
-  contexts?: EntityPermissions;
-  createdAt?: string;
-  externalData?: UserExternalData | null;
-}
-interface PartialUserPayload {
-  businessModels?: EntityPermissions;
-  fleets?: EntityPermissions;
-  demandSources?: EntityPermissions;
-  vehicles?: EntityPermissions;
-  drivers?: EntityPermissions;
-  businessAccounts?: EntityPermissions;
-}
-declare class ApiUser {
-  id?: string | undefined;
-  accountType?: AccountType | undefined;
-  contextIds?: string[] | undefined;
-  private privatePermissions;
-  private readonly privateElevatedPermissionsHash;
-  private privatePermissionsLegacy;
-  private readonly appPermission;
-  readonly emptyUser: boolean;
-  constructor(id?: string | undefined, accountType?: AccountType | undefined, elevatedPermissions?: PartialUserPayload, contextIds?: string[] | undefined);
-  getUserPermissions(): Promise<UserPayload>;
-  useCustomPermissionLoader(customPermissionLoader: (userId: string) => UserPayload | PromiseLike<UserPayload>): Promise<UserPayload>;
-  get businessModels(): string[];
-  get fleets(): string[];
-  get demandSources(): string[];
-  private getUserProperty;
-  get elevatedPermissions(): UserPayload;
-  get permissions(): UserPayload | undefined;
-  elevatePermissions(addedPermissions: PartialUserPayload): (() => void) & {
-    [Symbol.dispose]: () => void;
-  };
-  getUserPermissionsLegacy(): Promise<unknown>;
-  get permissionsLegacy(): any;
-  getUserAppPermissions(appId: string, clientSecret: string): Promise<UserPayload | undefined>;
-  extendRequiredContexts(contextIdsToAdd?: string[]): void;
-}
-//#endregion
-//#region src/user/common.d.ts
-type CustomPermissionLoader = (userId: string) => Promise<UserPayload>;
-interface AuthFromUserIdHeaderOptions {
-  eagerLoadUserPermissions?: boolean;
-  eagerLoadUserPermissionsLegacy?: boolean;
-  customPermissionLoader?: CustomPermissionLoader;
-}
-//#endregion
-//#region src/user/index.d.ts
-declare module "express-serve-static-core" {
-  interface Request {
-    user: ApiUser;
-  }
-}
-type Asyncify<T extends (...a: any[]) => any> = (...a: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
-declare const middleware: (options?: AuthFromUserIdHeaderOptions) => Asyncify<Handler>;
-declare const middlewareWithDecode: (options?: {
-  eagerLoadUserPermissions?: boolean;
-  eagerLoadUserPermissionsLegacy?: boolean;
-  returnErrorIfNoToken?: boolean;
-  appSecret?: string;
-}) => Asyncify<Handler>;
-declare const appMiddleware: (options: {
-  appId: string;
-  clientSecret: string;
-}) => Asyncify<Handler>;
-declare const eagerLoadPermissionsMiddleware: Asyncify<Handler>;
-declare const getDecodedBearer: (req: Request, appSecret?: string) => any;
-declare const createOrSetRabbitTrace: (trace: ReturnType<typeof newTrace$1> | undefined, userId: string | undefined, contextIds?: string[]) => Promise<void>;
-//#endregion
-//#region src/user/fastify.d.ts
-declare module "fastify" {
-  interface FastifyRequest {
-    user?: ApiUser;
-  }
-}
-declare const authFromUserIdHeaderPlugin: FastifyPluginCallback<AuthFromUserIdHeaderOptions>;
-//#endregion
-//#region src/check-permission.d.ts
-declare const getUser: () => ApiUser | undefined;
-declare const isUserExist: () => string | undefined;
-declare const checkFleetPermission: (fleetId: string) => boolean;
-declare const checkBusinessModelPermission: (businessModelId: string) => boolean;
-declare const checkDemandSourcePermission: (demandSourceId: string) => boolean;
-//#endregion
-//#region src/errors.d.ts
-declare class UnauthorizedAccessError extends Error {
-  user: ApiUser | null;
-  constructor(user?: ApiUser | null, message?: string);
-}
-//#endregion
-//#region src/secret-getter.d.ts
-declare const getRefreshTokenSecret: (token?: string) => string;
-declare const getTokenSecret: (token?: string) => string;
-//#endregion
-//#region src/authorization.d.ts
-declare const AUTHORIZATION_METHODS: {
-  NONE: string;
-  BASIC: string;
-  JWT: string;
+import * as outbreak from '@autofleet/outbreak';
+import User, { middleware, eagerLoadPermissionsMiddleware, middlewareWithDecode, getDecodedBearer, appMiddleware, createOrSetRabbitTrace } from './user';
+import { newTrace, traceTypes } from './tracer';
+import { checkFleetPermission, checkBusinessModelPermission, checkDemandSourcePermission, isUserExist, getUser } from './check-permission';
+import { UnauthorizedAccessError } from './errors';
+import { getRefreshTokenSecret, getTokenSecret } from './secret-getter';
+declare const getCurrentPayload: () => import("./tracer").Trace | {
+    [x: string]: never;
 };
-declare const getAuthorizationHeader: (authorizationSettings: {
-  method: string;
-} | undefined) => string | undefined;
-//#endregion
-//#region src/permissions/SDK/consts.d.ts
-declare const PERMISSIONS_EVALUATION_OPERATORS: {
-  AND: string;
-  OR: string;
-};
-declare const PERMISSION_ERROR_TYPES: {
-  USER_NOT_FOUND: string;
-  INSUFFICIENT_PERMISSIONS: string;
-  VALIDATION_ERROR: string;
-  API_ERROR: string;
-  NO_REQUIRED_PERMISSIONS: string;
-  UNAUTHORIZED: string;
-  BAD_REQUEST: string;
-  INTERNAL_ERROR: string;
-};
-//#endregion
-//#region src/permissions/SDK/errors.d.ts
-type PermissionErrorType = typeof PERMISSION_ERROR_TYPES[keyof typeof PERMISSION_ERROR_TYPES];
-//#endregion
-//#region src/permissions/SDK/types.d.ts
-interface Logger {
-  debug: (message: string, meta?: unknown) => void;
-  info: (message: string, meta?: unknown) => void;
-  warn: (message: string, meta?: unknown) => void;
-  error: (message: string, meta?: unknown) => void;
-}
-/**
-* The operator to use when evaluating permissions
-* - AND: All required permissions must be present
-* - OR: At least one required permission must be present
-*/
-type PermissionsEvaluationOperator = typeof PERMISSIONS_EVALUATION_OPERATORS[keyof typeof PERMISSIONS_EVALUATION_OPERATORS];
-/**
-* Options for evaluating permissions
-* - requireAll: If true, all contexts must have the required permissions for the user to be considered authorized (default: true)
-* - timeout: Optional - timeout in milliseconds for the permissions evaluation (default: 10 seconds)
-* - enforce: Optional - If true, the permissions evaluation will throw an error if the user does not have the required permissions (default: false)
-* - permissionsEvaluationOperator: Optional - If set, the permissions evaluation will use this operator to evaluate the permissions (default: AND)
-*/
-interface EvaluatePermissionsOpts {
-  requireAll?: boolean;
-  timeout?: number;
-  enforce?: boolean;
-  permissionsEvaluationOperator?: PermissionsEvaluationOperator;
-}
-/**
-* Parameters for evaluating permissions for a user across multiple contexts
-* - requiredPermissions: The required permissions to check against the user
-* - contextIds: The context IDs to check the permissions against
-* - logger: logger instance for logging
-* - options: Options for evaluating permissions {@link EvaluatePermissionsOpts}
-* - userId: The user id, if not provided, we will get the user from the current context
-*/
-interface EvaluatePermissionsParams {
-  requiredPermissions: string[];
-  contextIds: string[];
-  logger?: Logger;
-  options: EvaluatePermissionsOpts;
-  userId?: string;
-}
-/**
-* The permissions evaluation result for a specific context
-* - permissions: The full list of permissions the user has in the context
-* - hasRequiredPermissions: Whether the user has the required permissions in the context
-*/
-interface PermissionsEvaluation {
-  permissions: string[];
-  hasRequiredPermissions: boolean;
-}
-/**
-* A mapping of context IDs to their corresponding permissions evaluation results
-*/
-type PermissionsEvaluationByContextId = Record<string, PermissionsEvaluation>;
-/**
-* A mapping of context IDs to the list of permissions the user has in that context
-* - isAuthorized: Whether the user has the required permissions in any of the contexts
-* - userId: The ID of the user
-* - resolvedPermissions: The detailed permissions evaluation results by context ID
-* - requiredPermissions: The list of permissions that were required for the evaluation
-* - contextIds: The list of context IDs that were evaluated
-* - error: Optional error type if the evaluation failed
-* - message: Optional error message if the evaluation failed
-*/
-interface PermissionCheckResult {
-  isAuthorized: boolean;
-  userId?: string;
-  resolvedPermissions: PermissionsEvaluationByContextId;
-  requiredPermissions: string[];
-  contextIds: string[];
-  error?: PermissionErrorType;
-  message?: string;
-}
-//#endregion
-//#region src/permissions/SDK/evaluatePermissions.d.ts
-/**
-* Main SDK function to evaluate user permissions
-* Checks both cached and API-resolved permissions to determine access
-* @param params - {@link EvaluatePermissionsParams}
-* @returns {@link PermissionCheckResult} Detailed permission check result with access status and context
-*/
-declare const evaluatePermissions: ({
-  requiredPermissions,
-  contextIds,
-  logger,
-  userId,
-  options: {
-    requireAll,
-    permissionsEvaluationOperator,
-    timeout
-  }
-}: EvaluatePermissionsParams) => Promise<PermissionCheckResult>;
-//#endregion
-//#region src/permissions/middleware/requirePermissions.d.ts
-interface RequirePermissionsOptions extends EvaluatePermissionsOpts {
-  logger?: LoggerInstanceManager;
-}
-/**
-* Express middleware that requires specific permissions for route access
-*
-* @param requiredPermissions - Array of permissions required to access the route
-* @param options - Configuration options for permission checking
-* @returns Express middleware function
-*/
-declare const requirePermissions: (requiredPermissions: string[], options?: RequirePermissionsOptions) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
-declare namespace index_d_exports {
-  export { _default as default, middlewares, sdk };
-}
-interface SdkExports {
-  evaluatePermissions: typeof evaluatePermissions;
-}
-interface MiddlewareExports {
-  requirePermissions: typeof requirePermissions;
-}
-interface PermissionsModule {
-  sdk: SdkExports;
-  middlewares: MiddlewareExports;
-}
-declare const sdk: SdkExports;
-declare const middlewares: MiddlewareExports;
-declare const _default: PermissionsModule;
-//#endregion
-//#region src/index.d.ts
-declare const getCurrentPayload: typeof outbreak.getCurrentContext;
-type OutbreakOptions = Parameters<typeof outbreak.default>[0];
-type LoggerWithContextMiddleware = Partial<Pick<LoggerInstanceManager, "addContextMiddleware">>;
-declare const enableTracing: ({
-  outbreakOptions,
-  logger
-}?: {
-  outbreakOptions?: OutbreakOptions;
-  logger?: LoggerWithContextMiddleware;
+declare const enableTracing: ({ outbreakOptions }?: {
+    outbreakOptions?: {};
 }) => void;
-declare const traceTypes: typeof outbreak.traceTypes;
-declare const newTrace: typeof outbreak.newTrace;
-interface Default {
-  traceTypes: typeof outbreak.traceTypes;
-  newTrace: typeof outbreak.newTrace;
-  User: typeof ApiUser;
-  middleware: typeof middleware;
-  middlewareWithDecode: typeof middlewareWithDecode;
-  eagerLoadPermissionsMiddleware: typeof eagerLoadPermissionsMiddleware;
-  getCurrentPayload: typeof outbreak.getCurrentContext;
-  getDecodedBearer: typeof getDecodedBearer;
-  checkFleetPermission: typeof checkFleetPermission;
-  checkBusinessModelPermission: typeof checkBusinessModelPermission;
-  checkDemandSourcePermission: typeof checkDemandSourcePermission;
-  isUserExist: typeof isUserExist;
-  getUser: typeof getUser;
-  UnauthorizedAccessError: typeof UnauthorizedAccessError;
-  appMiddleware: typeof appMiddleware;
-  createOrSetRabbitTrace: typeof createOrSetRabbitTrace;
-  outbreak: typeof outbreak;
-  AUTHORIZATION_METHODS: typeof AUTHORIZATION_METHODS;
-  getAuthorizationHeader: typeof getAuthorizationHeader;
-  CONTEXTS_IDS_HEADER: typeof CONTEXTS_IDS_HEADER;
-  authFromUserIdHeaderPlugin: typeof authFromUserIdHeaderPlugin;
-  permissions: typeof index_d_exports;
-}
-declare const zehutDefault: Default;
-//#endregion
-export { AUTHORIZATION_METHODS, CONTEXTS_IDS_HEADER, UnauthorizedAccessError, ApiUser as User, type UserPayload, appMiddleware, authFromUserIdHeaderPlugin, checkBusinessModelPermission, checkDemandSourcePermission, checkFleetPermission, createOrSetRabbitTrace, zehutDefault as default, eagerLoadPermissionsMiddleware, enableTracing, getAuthorizationHeader, getCurrentPayload, getDecodedBearer, getRefreshTokenSecret, getTokenSecret, getUser, isUserExist, middleware, middlewareWithDecode, newTrace, outbreak, index_d_exports as permissions, traceTypes };
-//# sourceMappingURL=index.d.ts.map
+export { traceTypes, newTrace, enableTracing, User, middleware, middlewareWithDecode, eagerLoadPermissionsMiddleware, getCurrentPayload, getDecodedBearer, checkFleetPermission, checkBusinessModelPermission, checkDemandSourcePermission, isUserExist, getUser, getRefreshTokenSecret, getTokenSecret, UnauthorizedAccessError, appMiddleware, createOrSetRabbitTrace, outbreak, };
+declare const _default: {
+    traceTypes: {
+        HTTP_REQUEST: string;
+        WEB_SOCKET: string;
+        RABBIT: string;
+    };
+    newTrace: (type: any) => import("./tracer").Trace;
+    User: typeof User;
+    middleware: (options?: {
+        eagerLoadUserPermissions?: boolean;
+        eagerLoadUserPermissionsLegacy?: boolean;
+        customPermissionLoader?: import("./user/ApiUser").CustomPermissionLoader;
+    }) => (req: any, res: any, next: any) => Promise<any>;
+    middlewareWithDecode: (options?: {
+        eagerLoadUserPermissions?: boolean;
+        eagerLoadUserPermissionsLegacy?: boolean;
+        returnErrorIfNoToken?: boolean;
+    }) => (req: any, res: any, next: any) => Promise<void>;
+    eagerLoadPermissionsMiddleware: (req: any, res: any, next: any) => Promise<any>;
+    getCurrentPayload: () => import("./tracer").Trace | {
+        [x: string]: never;
+    };
+    getDecodedBearer: (req: any) => any;
+    checkFleetPermission: (fleetId: any) => boolean;
+    checkBusinessModelPermission: (businessModelId: any) => boolean;
+    checkDemandSourcePermission: (demandSourceId: any) => boolean;
+    isUserExist: () => string;
+    getUser: () => User;
+    UnauthorizedAccessError: typeof UnauthorizedAccessError;
+    appMiddleware: (options: {
+        appId: string;
+        clientSecret: string;
+    }) => (req: any, res: any, next: any) => Promise<void>;
+    createOrSetRabbitTrace: (trace: any, userId: any) => Promise<void>;
+    outbreak: typeof outbreak;
+};
+export default _default;