@betterinternship/core 2.16.7 → 2.16.8

package/README.md

@@ -1,26 +1,26 @@
-# Package.Core
-
-Contains dependencies shared between the different services of the site.
-
-## How to update
-
-1. Build the package:
-
-```bash
-npm run build
-```
-
-2. Commit the build:
-
-```bash
-git add .
-git commit -m "<follow conventional commits, k thanks>"
-git push
-```
-
-3. Update the version and publish the package to NPM:
-
-```bash
-npm version <patch|minor|major>
-npm publish
-```
+# Package.Core
+
+Contains dependencies shared between the different services of the site.
+
+## How to update
+
+1. Build the package:
+
+```bash
+npm run build
+```
+
+2. Commit the build:
+
+```bash
+git add .
+git commit -m "<follow conventional commits, k thanks>"
+git push
+```
+
+3. Update the version and publish the package to NPM:
+
+```bash
+npm version <patch|minor|major>
+npm publish
+```

package/dist/lib/broker/base.process.d.ts

@@ -1,2 +1,2 @@
-export declare class BaseProcess {
-}
+export declare class BaseProcess {
+}

package/dist/lib/broker/base.process.js

@@ -1,3 +1,3 @@
-export class BaseProcess {
-}
+export class BaseProcess {
+}
 //# sourceMappingURL=base.process.js.map

package/dist/lib/broker/base.task.d.ts

@@ -1,40 +1,40 @@
-import { Task, Process } from '@betterinternship/db';
-import { JsonValue } from '@prisma/client/runtime/client';
-export interface BaseJson {
-    [key: string]: any;
-}
-export declare class TaskRequest<TaskInputs extends JsonValue> implements Pick<Task, 'inputs' | 'internal_id' | 'handler_id' | 'parent_id' | 'process_id' | 'timestamp'> {
-    inputs: TaskInputs;
-    internal_id: string;
-    handler_id: string;
-    parent_id: string | null;
-    process_id: string;
-    timestamp: Date;
-}
-export declare class TaskResponse<TaskResult extends JsonValue> implements Pick<Task, 'result' | 'status' | 'error'> {
-    result: TaskResult;
-    error: string;
-    status: string;
-}
-type TaskResponseHandler<TaskResult extends JsonValue> = (response: TaskResponse<TaskResult>) => Promise<void>;
-export declare class BaseTaskInitiator<TaskInputs extends JsonValue, TaskResult extends JsonValue> {
-    private handlerId;
-    private requestQueueId;
-    private responseQueueId;
-    constructor(queueId: string, handler: TaskResponseHandler<TaskResult>);
-    init(handler: TaskResponseHandler<TaskResult>): Promise<void>;
-    sendTaskRequest(process: Process, inputs: TaskInputs, options: {
-        internalId?: string;
-        parentId?: string;
-        maxRetries?: number;
-    }): Promise<boolean>;
-}
-type TaskRequestHandler<TaskInputs extends JsonValue, TaskResult extends JsonValue> = (task: TaskRequest<TaskInputs>) => Promise<TaskResponse<TaskResult>>;
-export declare class BaseTaskRunner<TaskInputs extends JsonValue, TaskResult extends JsonValue> {
-    private requestQueueId;
-    private responseQueueId;
-    private handler;
-    constructor(queueId: string, handler: TaskRequestHandler<TaskInputs, TaskResult>);
-    listen(processName?: string): Promise<void>;
-}
-export {};
+import { Task, Process } from '@betterinternship/db';
+import { JsonValue } from '@prisma/client/runtime/client';
+export interface BaseJson {
+    [key: string]: any;
+}
+export declare class TaskRequest<TaskInputs extends JsonValue> implements Pick<Task, 'inputs' | 'internal_id' | 'handler_id' | 'parent_id' | 'process_id' | 'timestamp'> {
+    inputs: TaskInputs;
+    internal_id: string;
+    handler_id: string;
+    parent_id: string | null;
+    process_id: string;
+    timestamp: Date;
+}
+export declare class TaskResponse<TaskResult extends JsonValue> implements Pick<Task, 'result' | 'status' | 'error'> {
+    result: TaskResult;
+    error: string;
+    status: string;
+}
+type TaskResponseHandler<TaskResult extends JsonValue> = (response: TaskResponse<TaskResult>) => Promise<void>;
+export declare class BaseTaskInitiator<TaskInputs extends JsonValue, TaskResult extends JsonValue> {
+    private handlerId;
+    private requestQueueId;
+    private responseQueueId;
+    constructor(queueId: string, handler: TaskResponseHandler<TaskResult>);
+    init(handler: TaskResponseHandler<TaskResult>): Promise<void>;
+    sendTaskRequest(process: Process, inputs: TaskInputs, options: {
+        internalId?: string;
+        parentId?: string;
+        maxRetries?: number;
+    }): Promise<boolean>;
+}
+type TaskRequestHandler<TaskInputs extends JsonValue, TaskResult extends JsonValue> = (task: TaskRequest<TaskInputs>) => Promise<TaskResponse<TaskResult>>;
+export declare class BaseTaskRunner<TaskInputs extends JsonValue, TaskResult extends JsonValue> {
+    private requestQueueId;
+    private responseQueueId;
+    private handler;
+    constructor(queueId: string, handler: TaskRequestHandler<TaskInputs, TaskResult>);
+    listen(processName?: string): Promise<void>;
+}
+export {};

package/dist/lib/broker/base.task.js

@@ -1,88 +1,88 @@
-import { BrokerAPI } from './broker.js';
-import { tasks } from '@betterinternship/db';
-import { v4 } from 'uuid';
-export class TaskRequest {
-    inputs;
-    internal_id;
-    handler_id;
-    parent_id;
-    process_id;
-    timestamp;
-}
-export class TaskResponse {
-    result;
-    error;
-    status;
-}
-export class BaseTaskInitiator {
-    handlerId;
-    requestQueueId;
-    responseQueueId;
-    constructor(queueId, handler) {
-        this.handlerId = queueId;
-        this.requestQueueId = `request.${queueId}`;
-        this.responseQueueId = `response.${queueId}`;
-        void this.init(handler);
-    }
-    async init(handler) {
-        const brokerAPI = await BrokerAPI.instance();
-        return await brokerAPI.registerQueueHandler(this.responseQueueId, async (taskId) => {
-            const task = await tasks.findFirst({ where: { id: taskId } });
-            await handler({
-                result: task?.result,
-                error: task?.error ?? '',
-                status: task?.status ?? 'failed',
-            });
-        });
-    }
-    async sendTaskRequest(process, inputs, options) {
-        const brokerAPI = await BrokerAPI.instance();
-        const task = await tasks.create({
-            data: {
-                internal_id: options.internalId ?? `${process.id}.${v4()}`,
-                parent_id: options.parentId,
-                handler_id: this.handlerId,
-                process_id: process.id,
-                process_name: process.name,
-                inputs: inputs,
-            },
-        });
-        return brokerAPI.addToQueue(this.requestQueueId, task.id, options);
-    }
-}
-export class BaseTaskRunner {
-    requestQueueId;
-    responseQueueId;
-    handler;
-    constructor(queueId, handler) {
-        this.requestQueueId = `request.${queueId}`;
-        this.responseQueueId = `response.${queueId}`;
-        this.handler = handler;
-    }
-    async listen(processName) {
-        const taskRunner = async (taskId, actions) => {
-            const task = await tasks.findFirst({ where: { id: taskId } });
-            if (processName && processName !== task?.process_name)
-                return;
-            if (task?.parent_id && !task?.inputs)
-                return actions.hold();
-            const response = await this.handler(task);
-            await tasks.update({
-                where: { id: taskId },
-                data: {
-                    result: response.result ?? {},
-                    error: response.error ?? '',
-                    status: response.status,
-                },
-            });
-            if (response.error)
-                actions.reject();
-            else
-                actions.resolve();
-            await brokerAPI.addToQueue(this.responseQueueId, taskId);
-        };
-        const brokerAPI = await BrokerAPI.instance();
-        await brokerAPI.registerQueueHandler(this.requestQueueId, taskRunner);
-    }
-}
+import { BrokerAPI } from './broker.js';
+import { tasks } from '@betterinternship/db';
+import { v4 } from 'uuid';
+export class TaskRequest {
+    inputs;
+    internal_id;
+    handler_id;
+    parent_id;
+    process_id;
+    timestamp;
+}
+export class TaskResponse {
+    result;
+    error;
+    status;
+}
+export class BaseTaskInitiator {
+    handlerId;
+    requestQueueId;
+    responseQueueId;
+    constructor(queueId, handler) {
+        this.handlerId = queueId;
+        this.requestQueueId = `request.${queueId}`;
+        this.responseQueueId = `response.${queueId}`;
+        void this.init(handler);
+    }
+    async init(handler) {
+        const brokerAPI = await BrokerAPI.instance();
+        return await brokerAPI.registerQueueHandler(this.responseQueueId, async (taskId) => {
+            const task = await tasks.findFirst({ where: { id: taskId } });
+            await handler({
+                result: task?.result,
+                error: task?.error ?? '',
+                status: task?.status ?? 'failed',
+            });
+        });
+    }
+    async sendTaskRequest(process, inputs, options) {
+        const brokerAPI = await BrokerAPI.instance();
+        const task = await tasks.create({
+            data: {
+                internal_id: options.internalId ?? `${process.id}.${v4()}`,
+                parent_id: options.parentId,
+                handler_id: this.handlerId,
+                process_id: process.id,
+                process_name: process.name,
+                inputs: inputs,
+            },
+        });
+        return brokerAPI.addToQueue(this.requestQueueId, task.id, options);
+    }
+}
+export class BaseTaskRunner {
+    requestQueueId;
+    responseQueueId;
+    handler;
+    constructor(queueId, handler) {
+        this.requestQueueId = `request.${queueId}`;
+        this.responseQueueId = `response.${queueId}`;
+        this.handler = handler;
+    }
+    async listen(processName) {
+        const taskRunner = async (taskId, actions) => {
+            const task = await tasks.findFirst({ where: { id: taskId } });
+            if (processName && processName !== task?.process_name)
+                return;
+            if (task?.parent_id && !task?.inputs)
+                return actions.hold();
+            const response = await this.handler(task);
+            await tasks.update({
+                where: { id: taskId },
+                data: {
+                    result: response.result ?? {},
+                    error: response.error ?? '',
+                    status: response.status,
+                },
+            });
+            if (response.error)
+                actions.reject();
+            else
+                actions.resolve();
+            await brokerAPI.addToQueue(this.responseQueueId, taskId);
+        };
+        const brokerAPI = await BrokerAPI.instance();
+        await brokerAPI.registerQueueHandler(this.requestQueueId, taskRunner);
+    }
+}
 //# sourceMappingURL=base.task.js.map

package/dist/lib/broker/broker.d.ts

@@ -1,28 +1,28 @@
-import * as amqp from 'amqplib';
-export declare const Q: (...args: string[]) => string;
-export interface RequestBody {
-    taskId: string;
-}
-export type TaskResolver = () => void;
-export type TaskRejecter = () => void;
-export type TaskHolder = () => void;
-export type TaskHandler<T> = (taskId: string, actions: {
-    resolve: TaskResolver;
-    reject: TaskRejecter;
-    hold: TaskHolder;
-}) => Promise<T>;
-export declare class BrokerAPI {
-    connection: amqp.ChannelModel;
-    channels: Record<string, amqp.Channel>;
-    handlers: Record<string, TaskHandler<any>[]>;
-    private static __instance;
-    private constructor();
-    static instance(): Promise<BrokerAPI | null>;
-    private assertQueue;
-    private addToQueueWithHeaders;
-    addToQueue(queueId: string, taskId: string, options?: {
-        retries?: number;
-        maxRetries?: number;
-    }): Promise<boolean>;
-    registerQueueHandler<T>(queueId: string, handler: TaskHandler<T>): Promise<void>;
-}
+import * as amqp from 'amqplib';
+export declare const Q: (...args: string[]) => string;
+export interface RequestBody {
+    taskId: string;
+}
+export type TaskResolver = () => void;
+export type TaskRejecter = () => void;
+export type TaskHolder = () => void;
+export type TaskHandler<T> = (taskId: string, actions: {
+    resolve: TaskResolver;
+    reject: TaskRejecter;
+    hold: TaskHolder;
+}) => Promise<T>;
+export declare class BrokerAPI {
+    connection: amqp.ChannelModel;
+    channels: Record<string, amqp.Channel>;
+    handlers: Record<string, TaskHandler<any>[]>;
+    private static __instance;
+    private constructor();
+    static instance(): Promise<BrokerAPI | null>;
+    private assertQueue;
+    private addToQueueWithHeaders;
+    addToQueue(queueId: string, taskId: string, options?: {
+        retries?: number;
+        maxRetries?: number;
+    }): Promise<boolean>;
+    registerQueueHandler<T>(queueId: string, handler: TaskHandler<T>): Promise<void>;
+}

package/dist/lib/broker/broker.js

@@ -1,112 +1,112 @@
-import * as amqp from 'amqplib';
-import { ENV } from '../env.js';
-const RABBITMQ_ENABLED = ENV.RABBITMQ_ENABLED;
-const RABBITMQ_URL = ENV.RABBITMQ_URL;
-if (!RABBITMQ_URL && RABBITMQ_ENABLED)
-    throw new Error('[ERROR:ENV] Missing RabbitMQ configuration.');
-export const Q = (...args) => {
-    if (ENV.ENVIRONMENT === 'production')
-        return args.join('.');
-    else
-        return ['dev', ...args].join('.');
-};
-export class BrokerAPI {
-    connection;
-    channels = {};
-    handlers = {};
-    static __instance = null;
-    constructor() { }
-    static async instance() {
-        if (!RABBITMQ_ENABLED)
-            return Promise.resolve(null);
-        if (BrokerAPI.__instance)
-            return Promise.resolve(BrokerAPI.__instance);
-        const instance = new BrokerAPI();
-        instance.connection = await amqp.connect(RABBITMQ_URL);
-        instance.channels = {
-            asserter: await instance.connection.createChannel(),
-            reader: await instance.connection.createChannel(),
-            writer: await instance.connection.createChannel(),
-        };
-        BrokerAPI.__instance = instance;
-        return instance;
-    }
-    async assertQueue(queueId, options) {
-        const result = await this.channels.asserter.assertQueue(queueId, {
-            durable: true,
-            ...options,
-        });
-        console.log(`[BROKER] Queue "${queueId}" has been asserted.`);
-        return result;
-    }
-    async addToQueueWithHeaders(queueId, taskId, headers, options) {
-        await this.assertQueue(queueId);
-        const bodyStr = JSON.stringify({ taskId });
-        const result = this.channels.writer.sendToQueue(queueId, Buffer.from(bodyStr), {
-            persistent: true,
-            contentType: 'application/json',
-            headers: {
-                ...headers,
-                'x-retries': options?.retries ?? 0,
-                'x-max-retries': options?.maxRetries ?? 3,
-                'x-first-published': Date.now(),
-            },
-            messageId: taskId,
-        });
-        if (result) {
-            console.log(`[BROKER] Message sent to queue "${queueId}": ${bodyStr}.`);
-        }
-        else {
-            console.log(`[BROKER] Message could not sent to queue "${queueId}": ${bodyStr}.`);
-        }
-        return Promise.resolve(result);
-    }
-    async addToQueue(queueId, taskId, options) {
-        await this.assertQueue(queueId);
-        return this.addToQueueWithHeaders(queueId, taskId, {}, options);
-    }
-    async registerQueueHandler(queueId, handler) {
-        await this.assertQueue(queueId);
-        if (Object.keys(this.handlers).includes(queueId)) {
-            this.handlers[queueId].push(handler);
-            return;
-        }
-        const brokerAPI = this;
-        this.handlers[queueId] = [handler];
-        const resolve = (message) => () => {
-            this.channels.writer.ack(message);
-        };
-        const hold = (message) => () => {
-            this.channels.writer.nack(message, false, true);
-        };
-        const reject = (queueId, message) => () => {
-            const content = message?.content?.toString?.();
-            const request = JSON.parse(content);
-            const headers = message.properties.headers ?? {};
-            const retries = headers['x-retries'] ?? 0;
-            const maxRetries = headers['x-max-retries'] ?? 3;
-            if (retries >= maxRetries) {
-                this.channels.writer.ack(message);
-            }
-            else {
-                void this.addToQueueWithHeaders(queueId, request.taskId, headers, {
-                    retries: retries + 1,
-                    maxRetries,
-                }).then(() => this.channels.writer.ack(message));
-            }
-        };
-        await this.channels.reader.consume(queueId, (message) => {
-            const handlers = brokerAPI.handlers;
-            const content = message?.content?.toString?.();
-            const request = JSON.parse(content);
-            for (const handler of handlers[queueId]) {
-                void handler(request.taskId, {
-                    resolve: resolve(message),
-                    reject: reject(queueId, message),
-                    hold: hold(message),
-                });
-            }
-        });
-    }
-}
+import * as amqp from 'amqplib';
+import { ENV } from '../env.js';
+const RABBITMQ_ENABLED = ENV.RABBITMQ_ENABLED;
+const RABBITMQ_URL = ENV.RABBITMQ_URL;
+if (!RABBITMQ_URL && RABBITMQ_ENABLED)
+    throw new Error('[ERROR:ENV] Missing RabbitMQ configuration.');
+export const Q = (...args) => {
+    if (ENV.ENVIRONMENT === 'production')
+        return args.join('.');
+    else
+        return ['dev', ...args].join('.');
+};
+export class BrokerAPI {
+    connection;
+    channels = {};
+    handlers = {};
+    static __instance = null;
+    constructor() { }
+    static async instance() {
+        if (!RABBITMQ_ENABLED)
+            return Promise.resolve(null);
+        if (BrokerAPI.__instance)
+            return Promise.resolve(BrokerAPI.__instance);
+        const instance = new BrokerAPI();
+        instance.connection = await amqp.connect(RABBITMQ_URL);
+        instance.channels = {
+            asserter: await instance.connection.createChannel(),
+            reader: await instance.connection.createChannel(),
+            writer: await instance.connection.createChannel(),
+        };
+        BrokerAPI.__instance = instance;
+        return instance;
+    }
+    async assertQueue(queueId, options) {
+        const result = await this.channels.asserter.assertQueue(queueId, {
+            durable: true,
+            ...options,
+        });
+        console.log(`[BROKER] Queue "${queueId}" has been asserted.`);
+        return result;
+    }
+    async addToQueueWithHeaders(queueId, taskId, headers, options) {
+        await this.assertQueue(queueId);
+        const bodyStr = JSON.stringify({ taskId });
+        const result = this.channels.writer.sendToQueue(queueId, Buffer.from(bodyStr), {
+            persistent: true,
+            contentType: 'application/json',
+            headers: {
+                ...headers,
+                'x-retries': options?.retries ?? 0,
+                'x-max-retries': options?.maxRetries ?? 3,
+                'x-first-published': Date.now(),
+            },
+            messageId: taskId,
+        });
+        if (result) {
+            console.log(`[BROKER] Message sent to queue "${queueId}": ${bodyStr}.`);
+        }
+        else {
+            console.log(`[BROKER] Message could not sent to queue "${queueId}": ${bodyStr}.`);
+        }
+        return Promise.resolve(result);
+    }
+    async addToQueue(queueId, taskId, options) {
+        await this.assertQueue(queueId);
+        return this.addToQueueWithHeaders(queueId, taskId, {}, options);
+    }
+    async registerQueueHandler(queueId, handler) {
+        await this.assertQueue(queueId);
+        if (Object.keys(this.handlers).includes(queueId)) {
+            this.handlers[queueId].push(handler);
+            return;
+        }
+        const brokerAPI = this;
+        this.handlers[queueId] = [handler];
+        const resolve = (message) => () => {
+            this.channels.writer.ack(message);
+        };
+        const hold = (message) => () => {
+            this.channels.writer.nack(message, false, true);
+        };
+        const reject = (queueId, message) => () => {
+            const content = message?.content?.toString?.();
+            const request = JSON.parse(content);
+            const headers = message.properties.headers ?? {};
+            const retries = headers['x-retries'] ?? 0;
+            const maxRetries = headers['x-max-retries'] ?? 3;
+            if (retries >= maxRetries) {
+                this.channels.writer.ack(message);
+            }
+            else {
+                void this.addToQueueWithHeaders(queueId, request.taskId, headers, {
+                    retries: retries + 1,
+                    maxRetries,
+                }).then(() => this.channels.writer.ack(message));
+            }
+        };
+        await this.channels.reader.consume(queueId, (message) => {
+            const handlers = brokerAPI.handlers;
+            const content = message?.content?.toString?.();
+            const request = JSON.parse(content);
+            for (const handler of handlers[queueId]) {
+                void handler(request.taskId, {
+                    resolve: resolve(message),
+                    reject: reject(queueId, message),
+                    hold: hold(message),
+                });
+            }
+        });
+    }
+}
 //# sourceMappingURL=broker.js.map

package/dist/lib/broker/index.d.ts

@@ -1,2 +1,2 @@
-export * from './broker.js';
-export * from './base.task.js';
+export * from './broker.js';
+export * from './base.task.js';

package/dist/lib/broker/index.js

@@ -1,3 +1,3 @@
-export * from './broker.js';
-export * from './base.task.js';
+export * from './broker.js';
+export * from './base.task.js';
 //# sourceMappingURL=index.js.map

package/dist/lib/forms/field-preset-templates.js

@@ -5,14 +5,14 @@ const LONG_TEXT_VALIDATOR = `${TEXT_PREPROCESS}z.string().describe("textarea"))`
 const NUMBER_VALIDATOR = 'z.number()';
 const SIGNATURE_VALIDATOR = `${TEXT_PREPROCESS}z.string().nonempty({ message: "This field is required." }))`;
 const DROPDOWN_VALIDATOR = `z.enum(["Option 1", "Option 2"], {message:"This field is required."})`;
-const MULTISELECT_VALIDATOR = `z.array(
-  z.enum(
-    [
-      "Option 1",
-      "Option 2"
-    ],
-    { message: "This field is required." }
-  )
+const MULTISELECT_VALIDATOR = `z.array(
+  z.enum(
+    [
+      "Option 1",
+      "Option 2"
+    ],
+    { message: "This field is required." }
+  )
 ).describe("multiselect")`;
 const DATE_VALIDATOR = 'z.coerce.date()';
 const TIME_VALIDATOR = 'z.string().describe("time")';