Rc 1.5.0

00_Base/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@citrineos/base",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "The base module for OCPP v2.0.1 including all interfaces. This module is not intended to be used directly, but rather as a dependency for other modules.",
   "main": "dist/index.js",
   "module": "dist/esm/index.js",
@@ -44,4 +44,4 @@
     "uuid": "9.0.0",
     "zod": "3.22.3"
   }
-}
+}

00_Base/src/assertion/assertion.ts

@@ -28,16 +28,24 @@ export function notNull(object: any): boolean {
 
 /**
  * Ensures that obj2 contains all keys from obj1.
- * @param obj1 
- * @param obj2 
- * @returns 
+ * @param obj1
+ * @param obj2
+ * @returns
  */
 
-export function deepDirectionalEqual(obj1: any, obj2: any, seenObjects = new WeakSet()): boolean {
+export function deepDirectionalEqual(
+  obj1: any,
+  obj2: any,
+  seenObjects = new WeakSet(),
+): boolean {
   if (obj1 === obj2) return true;
 
-  if (typeof obj1 !== 'object' || obj1 === null ||
-    typeof obj2 !== 'object' || obj2 === null) {
+  if (
+    typeof obj1 !== 'object' ||
+    obj1 === null ||
+    typeof obj2 !== 'object' ||
+    obj2 === null
+  ) {
     return false;
   }
 
@@ -53,10 +61,13 @@ export function deepDirectionalEqual(obj1: any, obj2: any, seenObjects = new Wea
   const keys2 = Object.keys(obj2);
 
   for (const key of keys1) {
-    if (!keys2.includes(key) || !deepDirectionalEqual(obj1[key], obj2[key], seenObjects)) {
+    if (
+      !keys2.includes(key) ||
+      !deepDirectionalEqual(obj1[key], obj2[key], seenObjects)
+    ) {
       return false;
     }
   }
 
   return true;
-}
+}

00_Base/src/config/defineConfig.ts

@@ -67,7 +67,6 @@ const getZodSchemaKeyMap = (schema: z.ZodType): Record<string, any> => {
  * @param envVars The environment variables.
  * @returns The merged configuration.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function mergeConfigFromEnvVars<T extends Record<string, any>>(
   defaultConfig: T,
   envVars: NodeJS.ProcessEnv,

00_Base/src/index.ts

@@ -44,6 +44,9 @@ export {
   MessageTypeId,
   OcppError,
 } from './ocpp/rpc/message';
+export {
+  ChargingStationSequenceType,
+} from './ocpp/model/enums/requestIds';
 export { IFileAccess } from './interfaces/fileAccess';
 
 // Persistence Interfaces
@@ -244,3 +247,4 @@ export { assert, notNull, deepDirectionalEqual } from './assertion/assertion';
 export { UnauthorizedError } from './interfaces/api/exception/UnauthorizedError';
 export { AuthorizationSecurity } from './interfaces/api/AuthorizationSecurity';
 export { Ajv };
+export declare type Constructable<T> = new (...args: any[]) => T;

00_Base/src/interfaces/api/AbstractModuleApi.ts

@@ -13,15 +13,12 @@ import {
   METADATA_DATA_ENDPOINTS,
   METADATA_MESSAGE_ENDPOINTS,
 } from '.';
-import { OcppRequest, OcppResponse, SystemConfig } from '../..';
+import { MessageConfirmationSchema, OcppRequest, SystemConfig } from '../..';
 import { Namespace } from '../../ocpp/persistence';
 import { CallAction } from '../../ocpp/rpc/message';
 import { IMessageConfirmation } from '../messages';
 import { IModule } from '../modules';
-import {
-  IMessageQuerystring,
-  IMessageQuerystringSchema,
-} from './MessageQuerystring';
+import { IMessageQuerystringSchema } from './MessageQuerystring';
 import { IModuleApi } from './ModuleApi';
 import { AuthorizationSecurity } from './AuthorizationSecurity';
 
@@ -62,6 +59,7 @@ export abstract class AbstractModuleApi<T extends IModule>
         expose.action,
         expose.method,
         expose.bodySchema,
+        expose.optionalQuerystrings,
       );
     });
     (
@@ -111,13 +109,14 @@ export abstract class AbstractModuleApi<T extends IModule>
    * @param {CallAction} action - The action to be called.
    * @param {Function} method - The method to be executed.
    * @param {object} bodySchema - The schema for the route.
+   * @param {Record<string, any>} optionalQuerystrings - Optional querystrings for the route.
    * @return {void}
    */
-  // eslint-disable-next-line @typescript-eslint/ban-types
   protected _addMessageRoute(
     action: CallAction,
     method: (...args: any[]) => any,
     bodySchema: object,
+    optionalQuerystrings?: Record<string, any>,
   ): void {
     this._logger.debug(
       `Adding message route for ${action}`,
@@ -127,36 +126,55 @@ export abstract class AbstractModuleApi<T extends IModule>
     /**
      * Executes the handler function for the given request.
      *
-     * @param {FastifyRequest<{ Body: OcppRequest | OcppResponse, Querystring: IMessageQuerystring }>} request - The request object containing the body and querystring.
+     * @param {FastifyRequest<{ Body: OcppRequest, Querystring: IMessageQuerystring }>} request - The request object containing the body and querystring.
      * @return {Promise<IMessageConfirmation>} The promise that resolves to the message confirmation.
      */
     const _handler = async (
       request: FastifyRequest<{
-        Body: OcppRequest | OcppResponse;
-        Querystring: IMessageQuerystring;
+        Body: OcppRequest;
+        Querystring: Record<string, any>;
       }>,
-    ): Promise<IMessageConfirmation> =>
-      method.call(
+    ): Promise<IMessageConfirmation> => {
+      const { identifier, tenantId, callbackUrl, ...extraQueries } =
+        request.query;
+      return method.call(
         this,
-        request.query.identifier,
-        request.query.tenantId,
+        identifier,
+        tenantId,
         request.body,
-        request.query.callbackUrl,
+        callbackUrl,
+        Object.keys(extraQueries).length > 0 ? extraQueries : undefined,
       );
+    };
 
-    const _opts = {
+    const mergedQuerySchema = {
+      ...IMessageQuerystringSchema,
+      properties: {
+        ...IMessageQuerystringSchema.properties,
+        ...(optionalQuerystrings || {}),
+      },
+    };
+
+    const _opts: any = {
+      method: HttpMethod.Post,
+      url: this._toMessagePath(action),
+      handler: _handler,
       schema: {
         body: bodySchema,
-        querystring: IMessageQuerystringSchema,
+        querystring: mergedQuerySchema,
+        response: {
+          200: MessageConfirmationSchema,
+        },
       } as const,
     };
 
     if (this._module.config.util.swagger?.exposeMessage) {
       this._server.register(async (fastifyInstance) => {
-        fastifyInstance.post(this._toMessagePath(action), _opts, _handler);
+        this.registerSchemaForOpts(fastifyInstance, _opts);
+        fastifyInstance.route(_opts);
       });
     } else {
-      this._server.post(this._toMessagePath(action), _opts, _handler);
+      this._server.route(_opts);
     }
   }
 
@@ -168,7 +186,6 @@ export abstract class AbstractModuleApi<T extends IModule>
    * @param {object} schema - The schema for the entity.
    * @return {void}
    */
-  // eslint-disable-next-line @typescript-eslint/ban-types
   protected _addDataRoute(
     namespace: Namespace,
     method: (...args: any[]) => any,
@@ -265,13 +282,153 @@ export abstract class AbstractModuleApi<T extends IModule>
 
     if (this._module.config.util.swagger?.exposeData) {
       this._server.register(async (fastifyInstance) => {
+        this.registerSchemaForOpts(fastifyInstance, _opts);
         fastifyInstance.route<{ Body: object; Querystring: object }>(_opts);
       });
     } else {
       this._server.route<{ Body: object; Querystring: object }>(_opts);
     }
   }
 
+  private registerSchemaForOpts = (
+    fastifyInstance: FastifyInstance,
+    _opts: any,
+  ) => {
+    if (_opts.schema['querystring']) {
+      _opts.schema['querystring'] = this.registerSchema(
+        fastifyInstance,
+        _opts.schema['querystring'],
+      );
+    }
+    if (_opts.schema['body']) {
+      _opts.schema['body'] = this.registerSchema(
+        fastifyInstance,
+        _opts.schema['body'],
+      );
+    }
+    if (_opts.schema['params']) {
+      _opts.schema['params'] = this.registerSchema(
+        fastifyInstance,
+        _opts.schema['params'],
+      );
+    }
+    if (_opts.schema['headers']) {
+      _opts.schema['headers'] = this.registerSchema(
+        fastifyInstance,
+        _opts.schema['headers'],
+      );
+    }
+    if (_opts.schema['response']) {
+      _opts.schema['response'] = {
+        200: this.registerSchema(
+          fastifyInstance,
+          _opts.schema['response'][200],
+        ),
+      };
+    }
+  };
+
+  protected registerSchema = (
+    fastifyInstance: FastifyInstance,
+    schema: any,
+  ): object | null => {
+    const id = schema['$id'];
+    if (!id) {
+      this._logger.error('Could not register schema because no ID', schema);
+    }
+    try {
+      const schemaCopy = this.removeUnknownKeys(schema);
+      if (
+        schemaCopy.required &&
+        Array.isArray(schemaCopy.required) &&
+        schemaCopy.required.length === 0
+      ) {
+        delete schemaCopy.required;
+      }
+      if (schema.definitions) {
+        Object.keys(schema.definitions).forEach((key) => {
+          const definition = schema.definitions[key];
+          if (!definition['$id']) {
+            definition['$id'] = key;
+          }
+          this.registerSchema(fastifyInstance, definition);
+        });
+      }
+      if (schemaCopy.properties) {
+        Object.keys(schemaCopy.properties).forEach((key) => {
+          const property = schemaCopy.properties[key];
+          if (property.$ref) {
+            property.$ref = property.$ref.replace('#/definitions/', '');
+          }
+          if (property.items && property.items.$ref) {
+            property.items.$ref = property.items.$ref.replace(
+              '#/definitions/',
+              '',
+            );
+          }
+        });
+      }
+      fastifyInstance.addSchema(schemaCopy);
+      this._server.addSchema(schemaCopy);
+      return {
+        $ref: `${id}`,
+      };
+    } catch (e: any) {
+      // ignore already declared
+      if (e.code === 'FST_ERR_SCH_ALREADY_PRESENT') {
+        return {
+          $ref: `${id}`,
+        };
+      } else {
+        this._logger.error('Could not register schema', e, schema);
+      }
+      return null;
+    }
+  };
+
+  // TODO: for performance reasons can these unknown keys be removed directly from schemas?
+  private removeUnknownKeys = (schema: any): any => {
+    // Create a deep copy of the schema
+    const schemaCopy = structuredClone(schema); // Use structuredClone for a true deep copy
+
+    const cleanSchema = (obj: any) => {
+      if (typeof obj !== 'object' || obj === null) return;
+
+      // Remove specific unknown keys
+      for (const unknownKey of ['comment', 'javaType', 'tsEnumNames']) {
+        if (unknownKey in obj) {
+          delete obj[unknownKey];
+        }
+      }
+
+      // Remove `additionalItems` if `items` is not an array
+      if (
+        'items' in obj &&
+        !Array.isArray(obj.items) &&
+        'additionalItems' in obj
+      ) {
+        delete obj.additionalItems;
+      }
+
+      // Remove `additionalProperties` if `type` is not "object"
+      if ('additionalProperties' in obj && obj.type !== 'object') {
+        delete obj.additionalProperties;
+      }
+
+      // Recursively process nested objects
+      for (const key in obj) {
+        if (typeof obj[key] === 'object') {
+          cleanSchema(obj[key]);
+        }
+      }
+    };
+
+    // Clean the copied schema
+    cleanSchema(schemaCopy);
+
+    return schemaCopy;
+  };
+
   /**
    * Convert a {@link CallAction} to a normed lowercase URL path.
    *

00_Base/src/interfaces/api/AsDataEndpoint.ts

@@ -31,7 +31,6 @@ export const AsDataEndpoint = function (
   security?: object[],
   description?: string,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   return (
     target: any,
     propertyKey: string,
@@ -44,6 +43,10 @@ export const AsDataEndpoint = function (
       METADATA_DATA_ENDPOINTS,
       target.constructor,
     ) as Array<IDataEndpointDefinition>;
+    let tagList: string[] | undefined = undefined;
+    if (tags) {
+      tagList = Array.isArray(tags) ? tags : [tags];
+    }
     dataEndpoints.push({
       method: descriptor.value,
       methodName: propertyKey,
@@ -54,7 +57,7 @@ export const AsDataEndpoint = function (
       paramSchema: paramSchema,
       headerSchema: headerSchema,
       responseSchema: responseSchema,
-      tags: (Array.isArray(tags) ? tags : [tags]) as string[],
+      tags: tagList,
       description: description,
       security: security,
     });