@defra/forms-engine-plugin 0.1.19 → 0.1.21

package/.server/server/services/cacheService.d.ts

@@ -0,0 +1,49 @@
+import { type Request, type Server } from '@hapi/hapi';
+import { type FormPayload, type FormState, type FormSubmissionError, type FormSubmissionState } from '~/src/server/plugins/engine/types.js';
+import { type FormRequest, type FormRequestPayload } from '~/src/server/routes/types.js';
+declare enum ADDITIONAL_IDENTIFIER {
+    Confirmation = ":confirmation"
+}
+export declare class CacheService {
+    /**
+     * This service is responsible for getting, storing or deleting a user's session data in the cache. This service has been registered by {@link createServer}
+     */
+    cache: import("@hapi/catbox").Policy<unknown, {
+        cache: string | undefined;
+        segment: string;
+    }>;
+    logger: Server['logger'];
+    constructor(server: Server, cacheName?: string);
+    getState(request: Request | FormRequest | FormRequestPayload): Promise<FormSubmissionState>;
+    setState(request: FormRequest | FormRequestPayload, state: FormSubmissionState): Promise<FormSubmissionState>;
+    getConfirmationState(request: FormRequest | FormRequestPayload): Promise<{
+        confirmed?: true;
+    }>;
+    setConfirmationState(request: FormRequest | FormRequestPayload, confirmationState: {
+        confirmed?: true;
+    }): Promise<void>;
+    clearState(request: FormRequest | FormRequestPayload): Promise<void>;
+    getFlash(request: FormRequest | FormRequestPayload): {
+        errors: FormSubmissionError[];
+    } | undefined;
+    setFlash(request: FormRequest | FormRequestPayload, message: {
+        errors: FormSubmissionError[];
+    }): void;
+    /**
+     * The key used to store user session data against.
+     * If there are multiple forms on the same runner instance, for example `form-a` and `form-a-feedback` this will prevent CacheService from clearing data from `form-a` if a user gave feedback before they finished `form-a`
+     * @param request - hapi request object
+     * @param additionalIdentifier - appended to the id
+     */
+    Key(request: Request | FormRequest | FormRequestPayload, additionalIdentifier?: ADDITIONAL_IDENTIFIER): {
+        segment: string;
+        id: string;
+    };
+}
+/**
+ * State merge helper
+ * 1. Merges objects (form fields)
+ * 2. Overwrites arrays
+ */
+export declare function merge<StateType extends FormState | FormPayload>(state: StateType, update: object): StateType;
+export {};

package/.server/server/services/httpService.d.ts

@@ -0,0 +1,57 @@
+import Wreck from '@hapi/wreck';
+export type Method = keyof Pick<typeof Wreck, 'get' | 'post' | 'put' | 'delete'>;
+export type RequestOptions = Parameters<typeof Wreck.defaults>[0];
+export declare const request: <BodyType = Buffer<ArrayBufferLike>>(method: Method, url: string, options?: RequestOptions) => Promise<{
+    res: import("http").IncomingMessage;
+    error: Error | NonNullable<BodyType>;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: BodyType;
+    error?: undefined;
+}>;
+export declare const get: <BodyType>(url: string, options?: RequestOptions) => Promise<{
+    res: import("http").IncomingMessage;
+    error: Error | NonNullable<BodyType>;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: BodyType;
+    error?: undefined;
+}>;
+export declare const getJson: <BodyType extends object>(url: string) => Promise<{
+    res: import("http").IncomingMessage;
+    error: Error | BodyType;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: BodyType;
+    error?: undefined;
+}>;
+export declare const post: <BodyType>(url: string, options: RequestOptions) => Promise<{
+    res: import("http").IncomingMessage;
+    error: Error | NonNullable<BodyType>;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: BodyType;
+    error?: undefined;
+}>;
+export declare const postJson: <BodyType extends object>(url: string, options: RequestOptions) => Promise<{
+    res: import("http").IncomingMessage;
+    error: Error | BodyType;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: BodyType;
+    error?: undefined;
+}>;
+export declare const put: <BodyType>(url: string, options: RequestOptions) => Promise<{
+    res: import("http").IncomingMessage;
+    error: Error | NonNullable<BodyType>;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: BodyType;
+    error?: undefined;
+}>;

package/.server/server/services/index.d.ts

@@ -0,0 +1 @@
+export { CacheService } from '~/src/server/services/cacheService.js';

package/.server/server/types.d.ts

@@ -0,0 +1,31 @@
+import { type FormDefinition, type FormMetadata, type SubmitPayload, type SubmitResponsePayload } from '@defra/forms-model';
+import { type FormModel } from '~/src/server/plugins/engine/models/index.js';
+import { type DetailItem } from '~/src/server/plugins/engine/models/types.js';
+import { type PageController } from '~/src/server/plugins/engine/pageControllers/PageController.js';
+import { type FormRequestPayload, type FormStatus } from '~/src/server/routes/types.js';
+export interface FormsService {
+    getFormMetadata: (slug: string) => Promise<FormMetadata>;
+    getFormDefinition: (id: string, state: FormStatus) => Promise<FormDefinition | undefined>;
+}
+export interface FormSubmissionService {
+    persistFiles: (files: {
+        fileId: string;
+        initiatedRetrievalKey: string;
+    }[], persistedRetrievalKey: string) => Promise<object>;
+    submit: (data: SubmitPayload) => Promise<SubmitResponsePayload | undefined>;
+}
+export interface Services {
+    formsService: FormsService;
+    formSubmissionService: FormSubmissionService;
+    outputService: OutputService;
+}
+export interface RouteConfig {
+    formFileName?: string;
+    formFilePath?: string;
+    enforceCsrf?: boolean;
+    services?: Services;
+    controllers?: Record<string, typeof PageController>;
+}
+export interface OutputService {
+    submit: (request: FormRequestPayload, model: FormModel, emailAddress: string, items: DetailItem[], submitResponse: SubmitResponsePayload) => Promise<void>;
+}

package/.server/server/utils/file-form-service.d.ts

@@ -0,0 +1,50 @@
+/**
+ * FileFormService class
+ */
+export class FileFormService {
+    /**
+     * Add form from a file
+     * @param {string} filepath - the file path
+     * @param {FormMetadata} metadata - the metadata to use for this form
+     * @returns {Promise<FormDefinition>}
+     */
+    addForm(filepath: string, metadata: FormMetadata): Promise<FormDefinition>;
+    /**
+     * Read the form definition from file
+     * @param {string} filepath - the file path
+     * @returns {Promise<FormDefinition>}
+     */
+    readForm(filepath: string): Promise<FormDefinition>;
+    /**
+     * Read the form definition from a json file
+     * @param {string} filepath - the file path
+     * @returns {Promise<FormDefinition>}
+     */
+    readJsonForm(filepath: string): Promise<FormDefinition>;
+    /**
+     * Read the form definition from a yaml file
+     * @param {string} filepath - the file path
+     * @returns {Promise<FormDefinition>}
+     */
+    readYamlForm(filepath: string): Promise<FormDefinition>;
+    /**
+     * Get the form metadata by slug
+     * @param {string} slug - the form slug
+     * @returns {FormMetadata}
+     */
+    getFormMetadata(slug: string): FormMetadata;
+    /**
+     * Get the form defintion by id
+     * @param {string} id - the form id
+     * @returns {FormDefinition}
+     */
+    getFormDefinition(id: string): FormDefinition;
+    /**
+     * Returns a FormsService compliant interface
+     * @returns {import('~/src/server/types.js').FormsService}
+     */
+    toFormsService(): import("~/src/server/types.js").FormsService;
+    #private;
+}
+import type { FormMetadata } from '@defra/forms-model';
+import type { FormDefinition } from '@defra/forms-model';

package/.server/server/utils/notify.d.ts

@@ -0,0 +1,17 @@
+export interface SendNotificationArgs {
+    templateId: string;
+    emailAddress: string;
+    personalisation: {
+        subject: string;
+        body: string;
+    };
+}
+export declare function sendNotification(args: SendNotificationArgs): Promise<{
+    res: import("http").IncomingMessage;
+    error: object | Error;
+    payload?: undefined;
+} | {
+    res: import("http").IncomingMessage;
+    payload: object;
+    error?: undefined;
+}>;

package/.server/server/utils/secure-context/get-trust-store-certs.d.ts

@@ -0,0 +1 @@
+export function getTrustStoreCerts(envs: NodeJS.ProcessEnv): string[];

package/.server/server/utils/type-utils.d.ts

@@ -0,0 +1,3 @@
+import { type JoiExpression, type LanguageMessages, type LanguageMessagesExt } from 'joi';
+export declare function convertToLanguageMessages(extLanguageMessages: LanguageMessagesExt): LanguageMessages;
+export declare function createJoiExpression(expr: string): JoiExpression;

package/.server/server/utils/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a set of headers to use in an HTTP request, merging them with any existing headers in options.
+ * @param {Record<string, string> | undefined} [existingHeaders] - Optional existing headers to merge with the tracing headers.
+ * @param {string} [header] - The tracing header name to use.
+ * @returns {Record<string, string> | undefined} The merged headers, or undefined if no tracing header is available.
+ */
+export function applyTraceHeaders(existingHeaders?: Record<string, string> | undefined, header?: string): Record<string, string> | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra/forms-engine-plugin",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Defra forms engine",
   "type": "module",
   "files": [
@@ -29,9 +29,10 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "npm run build:server && npm run build:client",
+    "build": "rm -rf ./.server && npm run build:server && npm run build:client && npm run build:types",
     "build:client": "NODE_ENV=${NODE_ENV:-production} webpack",
     "build:server": "babel --delete-dir-on-start --extensions \".js\",\".ts\" --ignore \"**/*.test.ts\" --copy-files --no-copy-ignored --source-maps --out-dir ./.server ./src",
+    "build:types": "tsc -p tsconfig.build.json",
     "dev": "concurrently \"npm run client:watch\" \"npm run server:watch:dev\" --kill-others --names \"client,server\" --prefix-colors \"red.dim,blue.dim\"",
     "dev:debug": "concurrently \"npm run client:watch\" \"npm run server:watch:debug\" --kill-others --names \"client,server\" --prefix-colors \"red.dim,blue.dim\"",
     "format": "npm run format:check -- --write",

package/src/server/plugins/engine/components/YesNoField.ts

@@ -42,6 +42,13 @@ export class YesNoField extends SelectionControlField {
    * For error preview page that shows all possible errors on a component
    */
   getAllPossibleErrors(): ErrorMessageTemplateList {
+    return YesNoField.getAllPossibleErrors()
+  }
+
+  /**
+   * Static version of getAllPossibleErrors that doesn't require a component instance.
+   */
+  static getAllPossibleErrors(): ErrorMessageTemplateList {
     return {
       baseErrors: [
         {