@pgds/api-interface 1.2.5

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@pgds/api-interface",
+  "description": "Api interface for pgds services",
+  "authors": "Florry",
+  "version": "1.2.5",
+  "main": "index.js",
+  "types": "types/",
+  "scripts": {
+    "prepublish": "npm run build",
+    "build": "tsc",
+    "pretest": "npm run build",
+    "test": "nyc --require ts-node/register --reporter=html mocha --colors",
+    "clean": "git clean -f -x -e node_modules/ -e coverage/"
+  },
+  "files": [
+    "**/*.d.ts",
+    "./index.js",
+    "lib/**/*.js",
+    "lib/**/*.js.map",
+    "lib/**/*.d.ts",
+    "errors/**/*.js",
+    "errors/**/*.js.map",
+    "errors/**/*.d.ts",
+    "constants/**/*.js",
+    "constants/**/*.js.map",
+    "constants/**/*.d.ts",
+    "utils/**/*.js",
+    "utils/**/*.js.map",
+    "utils/**/*.d.ts",
+    "client/**/*.js",
+    "client/**/*.js.map",
+    "client/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@types/restify": "^8.5.12",
+    "@types/restify-errors": "^4.3.9",
+    "@types/mongodb": "4.0.0",
+    "ajv": "8.17.1",
+    "ajv-formats": "3.0.1",
+    "axios": "1.7.9",
+    "bunyan": "1.8.15",
+    "bunyan-format": "^0.2.1",
+    "mustbe": "0.4.0",
+    "nyc": "^17.1.0",
+    "prom-client": "^12.0.0",
+    "restify": "^11.1.0",
+    "restify-errors": "8.0.2",
+    "semver": "^7.3.8",
+    "ts-node": "^10.9.2",
+    "ts-node-test-register": "^10.0.0",
+    "uuid": "9.0.1",
+    "typescript": "^5.7.2",
+    "typescript-json-schema": "0.65.1"
+  },
+  "devDependencies": {
+    "@types/bunyan-format": "0.2.9",
+    "@types/chai": "4.3.12",
+    "@types/mocha": "^10.0.6",
+    "@types/mockery": "^1.4.30",
+    "@types/nock": "11.1.0",
+    "@types/semver": "^7.3.13",
+    "@types/supertest": "^2.0.11",
+    "@types/uuid": "^8.3.4",
+    "chai": "^4.3.6",
+    "chai-subset": "^1.6.0",
+    "mocha": "10.2.0",
+    "mockery": "2.1.0",
+    "supertest": "6.3.4",
+    "nock": "13.5.5"
+  },
+  "directories": {
+    "example": "examples",
+    "lib": "lib",
+    "types": "types"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hiotlabs/hiot-api-interface.git"
+  },
+  "keywords": [
+    "restify"
+  ],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/hiotlabs/hiot-api-interface/issues"
+  },
+  "homepage": "https://github.com/hiotlabs/hiot-api-interface#readme",
+  "mocha": {
+    "extension": [
+      "ts",
+      "js"
+    ],
+    "spec": "test/**/*.test.{ts,js}"
+  },
+  "nyc": {
+    "exclude": [
+      "coverage",
+      "test",
+      "**/*.d.ts",
+      "**/*.js.map"
+    ]
+  }
+}

package/types/hiot.d.ts

@@ -0,0 +1,368 @@
+declare module "hiot" {
+  import { KafkaBroker } from "hiot-kafka-broker";
+  import { Db } from "mongodb";
+  import { Server } from "restify";
+
+  export class Locator {
+    db: Db;
+    broker: KafkaBroker;
+    api: Server;
+
+    private constructor();
+  }
+}
+
+declare module "hiot-app" {
+  import * as Logger from "bunyan";
+  import { KafkaBuilder } from "hiot-kafka";
+  import { MongoDbBuilder } from "hiot-mongodb";
+  import { Locator } from "hiot";
+
+  export let mongodb: () => MongoDbBuilder;
+  export let kafka: () => KafkaBuilder;
+  export let redis: () => any;
+  export let connectToAdditionalDb: (locatorKey: string) => any;
+
+  type WaitForConnectionOptions = {
+    host?: string;
+    server?: string;
+    port: number | string;
+    [x: string]: any;
+  };
+
+  function waitFor(): WaitForBuilder;
+
+  export class WaitForBuilder {
+    options: {
+      connections: any[];
+    };
+    connection(options: WaitForConnectionOptions): WaitForBuilder;
+    build(): (locator: Locator) => any;
+
+    private constructor();
+  }
+
+  function shutdown(): ShutdownBuilder;
+
+  export class ShutdownBuilder {
+    options: {
+      close: () => any;
+      logger: {
+        error: (...data: any[]) => void;
+      };
+    };
+    close(close: Function): ShutdownBuilder;
+    logger(logger: Logger): ShutdownBuilder;
+    build(): (locator: Locator) => Locator;
+
+    private constructor();
+  }
+
+  type StartAppOptions = {
+    logger: Logger;
+    onUncaughtException: Function;
+    handleException: Function;
+    dependencies?: ("mongodb" | "kafka" | "redis")[];
+    aliveFilePeriod?: number;
+  };
+
+  function startApp(options: StartAppOptions): Promise<Locator>;
+
+  function failed(logger: Logger): (reason: string) => void;
+}
+
+declare module "hiot-app/debug" {
+  import { Locator } from "hiot";
+
+  function debug(): (...args: any[]) => any;
+
+  export = debug;
+}
+
+declare module "hiot-app/health" {
+  import { Locator } from "hiot-app/locator";
+  import restify from "restify";
+
+  type DefineRoutesOptions = {
+    prefix: string;
+    readiness?: { dependencies: ("mongodb" | "kafka" | "redis")[] };
+    liveness?: { dependencies: ("mongodb" | "kafka" | "redis")[] };
+  };
+
+  type RestifyHandlers = {
+    defineRoutes: (api: restify.Server, locator: Locator, options: DefineRoutesOptions) => void;
+  };
+
+  export const restifyHandlers: RestifyHandlers;
+}
+
+declare module "hiot-kafka-broker" {
+  import * as Logger from "bunyan";
+
+  export type ConnectionOptions = {
+    logger: Logger;
+    createTopics: boolean;
+    clientId: string;
+    connectionString: string;
+    groupId: string;
+    startingOffset: number;
+  };
+
+  export type Envelope<
+    T = {
+      value: {
+        timestamp: number;
+        correlationId: string;
+        [x: string]: any;
+      };
+      key?: string;
+    }
+  > = {
+    /** Exists if the message was received from Kafka, should not be set when sending a message */
+    ack?: (...args) => void;
+    /** Exists if the message was received from Kafka, should not be set when sending a message */
+    reject?: (...args) => void;
+    topic: string;
+    partition: number;
+    message: T;
+  };
+
+  export class KafkaBroker {
+    handlers: { [topic: string]: Function };
+    connected: boolean;
+    producer: {
+      clientId: string;
+      connectionString: string;
+      logger: {
+        logLevel: 4;
+        logFunction: (...args: any[]) => void;
+      };
+      retries: {
+        attempts: 3;
+        delay: 200;
+      };
+    };
+
+    private constructor();
+
+    connect(options: ConnectionOptions): Promise<any>;
+
+    send(envelope: Envelope): Promise<void>;
+
+    sendBatch(envelopes: Envelope[]): Promise<void>;
+
+    consume(topic: string, handler: (...args: any[]) => any): Promise<void>;
+
+    close(): void;
+
+    refresh(): void;
+  }
+}
+
+declare module "hiot-kafka" {
+  import { KafkaBroker, Envelope } from "hiot-kafka-broker";
+  import * as Logger from "bunyan";
+  import { Locator } from "hiot-app/locator";
+
+  export = () => new KafkaBuilder();
+
+  export const broker: KafkaBroker;
+
+  export const createTopics: (client: any, topics: any) => any;
+
+  export const envelope: { parse: (consumer: any, payload: any, topic: any, partition: any, logger: Logger) => any };
+
+  export const logParser: (logger: Logger) => (...args: any[]) => void;
+
+  export class KafkaBuilder {
+    options: {
+      server: string;
+      port: number;
+      groupId: string;
+      clientId: string;
+      createTopics: boolean;
+      logger: {
+        error: (...data: any[]) => void;
+        debug: (...data: any[]) => void;
+        info: (...data: any[]) => void;
+        trace: (...data: any[]) => void;
+        warn: (...data: any[]) => void;
+      };
+      handlers: () => void;
+    };
+    logger(logger: Logger): KafkaBuilder;
+    handlers(handlers: string[] | (() => any)): KafkaBuilder;
+    config(config: {
+      logger?: any;
+      connectionString?: string;
+      server?: string;
+      port?: number | string;
+      groupId?: string;
+      clientId?: string;
+    }): KafkaBuilder;
+    build(): (locator: Locator) => Locator;
+
+    private constructor();
+  }
+}
+
+declare module "hiot-kafka/handleEnvelope" {
+  function handleEnvelope<T = any>(
+    callback: (envelope: Envelope, options: T) => any,
+    options: T,
+    logger: Logger,
+    handleError: (
+      err: any,
+      data: {
+        extra: {
+          envelope: Envelope;
+        };
+      }
+    ) => {}
+  ): Promise<void>;
+
+  export = handleEnvelope;
+}
+
+declare module "hiot-app/locator" {
+  import { KafkaBroker } from "hiot-kafka-broker";
+  import { Db } from "mongodb";
+
+  const db: Db;
+  const broker: KafkaBroker;
+  const api: any;
+
+  export = { db, broker, api };
+}
+
+declare module "hiot-mongodb" {
+  import { ClassLikeDeclaration } from "typescript";
+  import { ReqUser } from "../lib/models/ReqUser";
+  import { Collection, Db } from "mongodb";
+  import { KafkaBroker } from "hiot-kafka-broker";
+  import * as Logger from "bunyan";
+  import { Locator } from "hiot-app/locator";
+
+  export = () => new MongoDbBuilder();
+  export const createTopics: (client: any, topics: any) => any;
+  export const envelope: { parse: (consumer: any, payload: any, topic: any, partition: any, logger: Logger) => any };
+  export const logParser: (logger: Logger) => (...args: any[]) => void;
+
+  export const test = {
+    insert: (locator: Locator, context: any) => new Promise<void>(),
+  };
+
+  export class MongoDbBuilder {
+    options: {
+      server: string;
+      port: number;
+      groupId: string;
+      clientId: string;
+      createTopics: boolean;
+      logger: {
+        error: (...data: any[]) => void;
+        debug: (...data: any[]) => void;
+        info: (...data: any[]) => void;
+        trace: (...data: any[]) => void;
+        warn: (...data: any[]) => void;
+      };
+      handlers: () => void;
+    };
+    logger(logger: Logger): MongoDbBuilder;
+    handlers(handlers: any): MongoDbBuilder;
+    config(config: { host: string; port: number | string; database: string; replicaSet: string }): MongoDbBuilder;
+    build(): (locator: Locator) => Locator;
+
+    private constructor();
+  }
+
+  export enum ACL {
+    Write = "write",
+    Delete = "delete",
+    Read = "read",
+  }
+
+  export class Repository<T> {
+    name: string;
+    Type: T;
+    locator: Locator;
+
+    /**
+     * @param name mongodb collection name
+     * @param Type the (js) class definition for documents
+     * @param locator mongodb connection
+     */
+    constructor(name: string, Type: any, locator: Locator);
+
+    public getById(id: string, user?: ReqUser): Promise<T | undefined>;
+
+    public getAll(user: ReqUser | undefined, query: any): Promise<T[]>;
+
+    public getAllByPaging(query: any, sorting: any, size: number, page: number, user?: ReqUser): Promise<T[]>;
+
+    public getTotalCount(query: any): Promise<number>;
+
+    public patch(id: string, patch: any): Promise<T>;
+
+    public update(id: string, updateData: any, user?: ReqUser): Promise<T>;
+
+    public save(data: T, user?: ReqUser): Promise<T>;
+
+    public remove(id: string, user?: ReqUser): Promise<number>;
+
+    public collection(): Collection<T>;
+  }
+
+  export const queryBuilder: {
+    findFilter(user: ReqUser, search: any): any;
+
+    findOneFilter(id: string, user: ReqUser, acl: string): { $and: any[] };
+  };
+}
+
+declare module "hiot-app/httpClient" {
+  // import { AxiosInstance } from "axios";
+
+  type HttpForOptions = {
+    config: any;
+    apiUser?: string;
+    correlationId?: string;
+  };
+
+  function httpFor(options: HttpForOptions): any;
+
+  function handleResponse<T = any>(promise: PromiseLike, successStatus?: number): Promise<T>;
+
+  function fetchPaginatedResponse<T = any>(http: any, urlBasePath: string, pageSize: number = 50): Promise<T>;
+}
+
+declare module "hiot-app/setupNock" {
+  import nock from "nock";
+
+  function setupNock(): typeof nock;
+
+  export = setupNock;
+}
+
+declare module "hiot-app/generateHandleException" {
+  type Package = {
+    name: string;
+    version: number;
+    [x: string]: any;
+  };
+
+  type ProcessEnv = {
+    SENTRY_ENVIRONMENT?: string;
+    API_HOST?: string;
+  };
+
+  type GenerateHandleExceptionOptions = {
+    processEnv: any;
+    pkg: Package;
+    sentryRelease?: any;
+  };
+
+  function generateHandleException(options: GenerateHandleExceptionOptions): (err: any, metadata?: any) => any;
+
+  export = generateHandleException;
+}

package/types/mustbe/config/activities.d.ts

@@ -0,0 +1,11 @@
+export = Activities;
+declare function Activities(): void;
+declare class Activities {
+    config: {
+        validators: {};
+    };
+    can(activity: any, validator: any): void;
+    deny(denier: any): void;
+    allow(allower: any): void;
+}
+//# sourceMappingURL=activities.d.ts.map

package/types/mustbe/config/index.d.ts

@@ -0,0 +1,77 @@
+export = Configurator;
+
+declare function Configurator(): void;
+
+declare class Configurator {
+  activityRegistry: Registry;
+
+  identityRegistry: Registry;
+
+  routeHelpersConfig: RouteHelperConfig;
+
+  userIdentityConfig: UserIdentityConfig;
+
+  defaultIdentityType: string;
+
+  config: {
+    routeHelpers: {
+      validators: {};
+      getUser: (req: any, cb: any) => void;
+      parameterMaps: {};
+    };
+    userIdentity: {};
+    validators: {};
+    activities: Registry;
+    identities: Registry;
+    getActivities: (identityTypeName: any) => any;
+    getIdentity: (identityTypeName: any) => any;
+  };
+
+  getConfig(): {
+    routeHelpers: {
+      validators: {};
+      getUser: (req: any, cb: any) => void;
+      parameterMaps: {};
+    };
+    userIdentity: {};
+    validators: {};
+    activities: Registry;
+    identities: Registry;
+    getActivities: (identityTypeName: any) => any;
+    getIdentity: (identityTypeName: any) => any;
+  };
+
+  routeHelpers(cb: (config: RouteHelperConfig) => void): void;
+
+  userIdentity(cb: any): void;
+  addIdentity(identityTypeName: any, IdentityType: any): void;
+
+  activities(identityTypeName: any, cb: any): void;
+  activities(cb: (config: ActivityConfig) => void): void;
+}
+import Registry = require("../registry");
+import RouteHelperConfig = require("./route-helpers");
+import UserIdentityConfig = require("./user-identity");
+//# sourceMappingURL=index.d.ts.map
+
+declare class ActivityConfig {
+  config: {
+    validators: {};
+    denier: any;
+    allower: any;
+  };
+  can(activity: string, validator: (identity: any, params: any, cb: () => void) => void): void;
+  deny(denier: any): void;
+  allow(
+    cb: (
+      identity: {
+        user: {
+          userId: string;
+          activities: { [activity: string]: boolean };
+        };
+      },
+      activity: string,
+      cb: (err: any, permitted: boolean) => void
+    ) => void
+  ): void;
+}

package/types/mustbe/config/parameter-map.d.ts

@@ -0,0 +1,8 @@
+export = ParameterMap;
+declare function ParameterMap(): void;
+declare class ParameterMap {
+    maps: {};
+    getMaps(): {};
+    map(activity: any, mapper: any): void;
+}
+//# sourceMappingURL=parameter-map.d.ts.map

package/types/mustbe/config/route-helpers.d.ts

@@ -0,0 +1,17 @@
+export = RouteHelpers;
+declare function RouteHelpers(): void;
+import { Request, Response, Next } from "restify";
+
+declare class RouteHelpers {
+  config: {
+    validators: {};
+    getUser: typeof noGetUser;
+    parameterMaps: {};
+  };
+  getUser(cb: (req: Request, cb: (err: any, user: any) => void) => void): void;
+  notAuthenticated(cb: (req: Request, res: Response, next: Next) => void): void;
+  notAuthorized(cb: (req: Request, res: Response, next: Next) => void): void;
+  parameterMaps(cb: any): void;
+}
+declare function noGetUser(req: any, cb: any): void;
+//# sourceMappingURL=route-helpers.d.ts.map

package/types/mustbe/config/user-identity.d.ts

@@ -0,0 +1,7 @@
+export = UserIdentity;
+declare function UserIdentity(): void;
+declare class UserIdentity {
+    config: {};
+    isAuthenticated(cb: any): void;
+}
+//# sourceMappingURL=user-identity.d.ts.map

package/types/mustbe/core.d.ts

@@ -0,0 +1,23 @@
+export = MustBe;
+declare function MustBe(): void;
+import Configurator from "../../types/mustbe/config";
+declare class MustBe {
+  configure(cb: (config: Configurator) => void): void;
+  config: {
+    routeHelpers: {
+      validators: {};
+      getUser: (req: any, cb: any) => void;
+      parameterMaps: {};
+    };
+    userIdentity: {};
+    validators: {};
+    activities: import("./registry");
+    identities: import("./registry");
+    getActivities: (identityTypeName: any) => any;
+    getIdentity: (identityTypeName: any) => any;
+  };
+  routeHelpers(): RouteHelpers;
+  getIdentity(identityTypeName: any): any;
+}
+import RouteHelpers = require("./routeHelpers");
+//# sourceMappingURL=core.d.ts.map

package/types/mustbe/identities/userIdentity.d.ts

@@ -0,0 +1,10 @@
+export = UserIdentity;
+declare function UserIdentity(user: any, config: any): void;
+declare class UserIdentity {
+    constructor(user: any, config: any);
+    user: any;
+    config: any;
+    isAuthenticated(cb: any): any;
+    type: string;
+}
+//# sourceMappingURL=userIdentity.d.ts.map

package/types/mustbe/index.d.ts

@@ -0,0 +1,6 @@
+// TODO: Temp or permanent solution, mustbe has no types what so ever, so 🤷‍♂️ for now
+
+export = mustBe;
+declare var mustBe: MustBe;
+import MustBe = require("./core");
+//# sourceMappingURL=index.d.ts.map

package/types/mustbe/principals/index.d.ts

@@ -0,0 +1,10 @@
+export = Principal;
+declare function Principal(identity: any, verifier: any): void;
+declare class Principal {
+    constructor(identity: any, verifier: any);
+    identity: any;
+    verifier: any;
+    isAuthenticated(cb: any): void;
+    isAuthorized(activity: any, requestParams: any, cb: any): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/mustbe/registry.d.ts

@@ -0,0 +1,11 @@
+export = Registry;
+declare function Registry(defaultValue: any): void;
+declare class Registry {
+    constructor(defaultValue: any);
+    _defaultValue: any;
+    _values: any;
+    register(name: any, value: any): void;
+    get(name: any): any;
+    hasValue(name: any): any;
+}
+//# sourceMappingURL=registry.d.ts.map

package/types/mustbe/routeHelpers/index.d.ts

@@ -0,0 +1,20 @@
+export = RouteHelpers;
+declare function RouteHelpers(config: any): void;
+declare class RouteHelpers {
+  constructor(config: any);
+  config: any;
+  authenticated(notAuthCB?: any): (req: any, res: any, next: any, ...args: any[]) => void;
+  authorizeIdentity(
+    identityTypeName: any,
+    activity: any,
+    notauthcb: any
+  ): (req: any, res: any, next: any, ...args: any[]) => void;
+  authorized(activity: any, notauthcb?: any): (req: any, res: any, next: any, ...args: any[]) => void;
+  _handleAuthorization(
+    activity: any,
+    notauthcb: any,
+    getIdentitycb: any
+  ): (req: any, res: any, next: any, ...args: any[]) => void;
+  getIdentity(identityTypeName: any, config: any): any;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/mustbe/verifier/index.d.ts

@@ -0,0 +1,10 @@
+export = Verifier;
+declare function Verifier(identity: any, config: any): void;
+declare class Verifier {
+    constructor(identity: any, config: any);
+    identity: any;
+    config: any;
+    activities: any;
+    isAuthorized(activity: any, requestParams: any, cb: any): void;
+}
+//# sourceMappingURL=index.d.ts.map