@raclettejs/core 0.0.1

package/services/backend/src/core/contracting/contractRegistrar.ts

@@ -0,0 +1,140 @@
+import type {
+  PluginContract,
+  DataTypeContract,
+  DiscoveryResult,
+} from "./contractTypes"
+
+// Store plugin contracts: pluginKey -> contract
+const contracts: Record<string, PluginContract> = {}
+
+export const registerPluginContract = (
+  pluginKey: string,
+  contract: PluginContract,
+): void => {
+  if (contracts[pluginKey]) {
+    throw new Error(`Plugin contract for "${pluginKey}" is already registered`)
+  }
+
+  contracts[pluginKey] = contract
+}
+
+export const getPluginContract = (
+  pluginKey: string,
+): PluginContract | undefined => contracts[pluginKey]
+
+export const getDataTypeContract = (
+  pluginKey: string,
+  dataTypeName: string,
+): DataTypeContract | undefined => contracts[pluginKey]?.[dataTypeName]
+
+export const getAllPluginContracts = (): Record<string, PluginContract> =>
+  contracts
+
+export const getAllPluginKeys = (): string[] => Object.keys(contracts)
+
+export const getAvailableDataTypes = (): Record<string, string[]> => {
+  const result: Record<string, string[]> = {}
+
+  Object.entries(contracts).forEach(([pluginKey, contract]) => {
+    result[pluginKey] = Object.keys(contract)
+  })
+
+  return result
+}
+
+export const getDataTypeOperations = (
+  pluginKey: string,
+  dataTypeName: string,
+): string[] => {
+  const dataType = getDataTypeContract(pluginKey, dataTypeName)
+  return dataType?.operations ? Object.keys(dataType.operations) : []
+}
+
+export const callDataTypeOperation = async (
+  pluginKey: string,
+  dataTypeName: string,
+  operation: string,
+  ...args: any[]
+): Promise<any> => {
+  const dataType = getDataTypeContract(pluginKey, dataTypeName)
+
+  if (!dataType) {
+    throw new Error(
+      `DataType "${dataTypeName}" not found in plugin "${pluginKey}"`,
+    )
+  }
+
+  const operationFn = dataType.operations?.[operation]
+  if (!operationFn) {
+    throw new Error(
+      `Operation "${operation}" not provided by "${pluginKey}.${dataTypeName}"`,
+    )
+  }
+
+  return await operationFn(...args)
+}
+
+// Discovery functions
+export const findDataTypesByKeyword = (keyword: string): DiscoveryResult[] => {
+  const results: DiscoveryResult[] = []
+
+  Object.entries(contracts).forEach(([pluginKey, contract]) => {
+    Object.entries(contract).forEach(([dataTypeName, dataType]) => {
+      if (dataType.keywords?.includes(keyword)) {
+        results.push({
+          pluginKey,
+          dataTypeName,
+          keywords: dataType.keywords || [],
+          operations: dataType.operations
+            ? Object.keys(dataType.operations)
+            : [],
+        })
+      }
+    })
+  })
+
+  return results
+}
+
+export const findDataTypesWithOperation = (
+  operation: string,
+): DiscoveryResult[] => {
+  const results: DiscoveryResult[] = []
+
+  Object.entries(contracts).forEach(([pluginKey, contract]) => {
+    Object.entries(contract).forEach(([dataTypeName, dataType]) => {
+      if (dataType.operations?.[operation]) {
+        results.push({
+          pluginKey,
+          dataTypeName,
+          keywords: dataType.keywords || [],
+          operations: Object.keys(dataType.operations),
+        })
+      }
+    })
+  })
+
+  return results
+}
+
+export const getAllKeywords = (): string[] => {
+  const keywordSet = new Set<string>()
+
+  Object.values(contracts).forEach((contract) => {
+    Object.values(contract).forEach((dataType) => {
+      dataType.keywords?.forEach((keyword) => keywordSet.add(keyword))
+    })
+  })
+
+  return Array.from(keywordSet)
+}
+
+// Utility function to check if operation exists
+export const hasOperation = (
+  pluginKey: string,
+  dataTypeName: string,
+  operation: string,
+): boolean => {
+  const dataType = getDataTypeContract(pluginKey, dataTypeName)
+  return !!dataType?.operations?.[operation]
+}

package/services/backend/src/core/contracting/contractTypes.ts

@@ -0,0 +1,28 @@
+export interface DataTypeContract {
+  // Optional schema for type information
+  schema?: any
+
+  // Flexible operations - plugin defines what it provides
+  operations?: Record<string, Function>
+
+  // Keywords for discovery and connection suggestions
+  keywords?: string[]
+
+  // Optional metadata
+  metadata?: {
+    description?: string
+    version?: string
+  }
+}
+
+export interface PluginContract {
+  [dataTypeName: string]: DataTypeContract
+}
+
+// Helper type for discovery results
+export interface DiscoveryResult {
+  pluginKey: string
+  dataTypeName: string
+  keywords: string[]
+  operations: string[]
+}

package/services/backend/src/core/crud/crudRegistrar.ts

@@ -0,0 +1,32 @@
+import type { CrudHandlers } from "@c/crud/crudTypes"
+
+// Store CRUD handlers in a simple object
+const handlers: Record<string, CrudHandlers<any>> = {}
+const scopes: Record<string, Set<string>> = {}
+
+export const registerCrudHandlers = <T>(
+  type: string,
+  crudHandlers: CrudHandlers<T>,
+  scope = "core",
+): void => {
+  if (handlers[type]) {
+    throw new Error(`CRUD handlers for type "${type}" are already registered`)
+  }
+
+  handlers[type] = crudHandlers
+
+  // Register scope
+  scopes[scope] = scopes[scope] || new Set()
+  scopes[scope].add(type)
+}
+
+export const getCrudHandlers = <T>(type: string): CrudHandlers<T> | undefined =>
+  handlers[type]
+
+export const getAllCrudHandlers = (): Record<string, CrudHandlers<any>> =>
+  handlers
+
+export const getCrudHandlersByScope = (scope: string): CrudHandlers<any>[] =>
+  Array.from(scopes[scope] || []).map((type) => handlers[type])
+
+export const getAllTypes = (): string[] => Object.keys(handlers)

package/services/backend/src/core/crud/crudTypes.ts

@@ -0,0 +1,32 @@
+import type { ClientPayloadRequestData } from "../payload/payloadTypes"
+import type { FastifyInstance } from "fastify"
+
+export interface CrudHandlers<T> {
+  create: (
+    fastify: FastifyInstance,
+    requestParams: ClientPayloadRequestData,
+    data: Partial<T>,
+    userId: string,
+    broadcast?: boolean,
+  ) => Promise<any>
+  read: (
+    fastify: FastifyInstance,
+    requestParams: ClientPayloadRequestData,
+    id: string,
+  ) => Promise<any>
+  update: (
+    fastify: FastifyInstance,
+    requestParams: ClientPayloadRequestData,
+    id: string,
+    data: Partial<T>,
+    userId: string,
+    broadcast?: boolean,
+  ) => Promise<any>
+  delete: (
+    fastify: FastifyInstance,
+    requestParams: ClientPayloadRequestData,
+    id: string,
+    userId: string,
+    broadcast?: boolean,
+  ) => Promise<any>
+}

package/services/backend/src/core/eventBus/eventBusEventMap.ts

@@ -0,0 +1,82 @@
+export default {
+  dataNew: {},
+  dataCreated: {},
+  dataUpdated: {},
+  dataDeleted: {},
+  dataMoved: {},
+
+  journalTicketCreated: {},
+  journalTicketUpdated: {},
+  journalTicketMoved: {},
+  journalTicketDeleted: {},
+  journalTicketFileUploaded: {},
+  journalTicketFileDeleted: {},
+
+  coreTagCreated: {},
+  coreTagUpdated: {},
+  coreTagDeleted: {},
+  coreTagHardDeleted: {}, // fully deleted from DB
+  coreTagArrayUpdated: {},
+
+  coreUserCreated: {},
+  coreUserUpdated: {},
+  coreUserDeleted: {},
+  coreUserHardDeleted: {},
+
+  coreAccountCreated: {},
+  coreAccountUpdated: {},
+  coreAccountDeleted: {},
+  coreAccountHardDeleted: {},
+
+  coreProjectCreated: {},
+  coreProjectUpdated: {},
+  coreProjectDeleted: {},
+  coreProjectHardDeleted: {},
+
+  coreCompositionCreated: {},
+  coreCompositionUpdated: {},
+  coreCompositionDeleted: {},
+  coreCompositionHardDeleted: {},
+
+  coreInteractionLinkCreated: {},
+  coreInteractionLinkUpdated: {},
+  coreInteractionLinkDeleted: {},
+  coreInteractionLinkHardDeleted: {},
+
+  coreContentCreated: {},
+  coreContentUpdated: {},
+  coreContentDeleted: {},
+  coreContentHardDeleted: {},
+
+  coreProjectConfigUpdated: {},
+
+  broadcastDataCreated: {},
+  broadcastDataUpdated: {},
+  broadcastDataDeleted: {},
+  broadcastDataUpdatedSystem: {},
+
+  broadcastTicketCreated: {},
+  broadcastTicketDeleted: {},
+  broadcastTicketFileUploaded: {},
+  broadcastTicketFileDeleted: {},
+
+  broadcastTagCreated: {},
+  broadcastTagDeleted: {},
+
+  broadcastUserCreated: {},
+  broadcastUserDeleted: {},
+
+  broadcastInteractionLinkCreated: {},
+  broadcastInteractionLinkDeleted: {},
+
+  broadcastCompositionCreated: {},
+  broadcastCompositionDeleted: {},
+
+  broadcastProjectCreated: {},
+  broadcastProjectUpdated: {},
+
+  broadcastProjectConfigUpdated: {},
+
+  appReady: {},
+  broadcastNewVersionAvailable: {},
+}

package/services/backend/src/core/eventBus/index.ts

@@ -0,0 +1,14 @@
+/*
+ * Eventbus Plugin
+ *
+ * Adds a globally available event emitter to the fastify instance
+ */
+import type { FastifyInstance } from "fastify"
+import fastifyPlugin from "fastify-plugin"
+import eventMap from "./eventBusEventMap"
+import EventEmitter from "@c/events/eventEmitter"
+
+export default fastifyPlugin(async (fastify: FastifyInstance) => {
+  const eventbus = new EventEmitter(eventMap)
+  fastify.decorate("eventbus", eventbus)
+})

package/services/backend/src/core/events/eventEmitter.ts

@@ -0,0 +1,141 @@
+/*
+ * EventEmiter
+ * @class
+ *
+ * This class mimicks the nodejs EventEmitter. It is primarily used as the
+ * global eventbus so different parts of the application can communicate with
+ * each other without being tightly coupled.
+ * e.g. store -> http client, component -> http client, component -> socket etc.
+ */
+
+type Listener = (...args: any[]) => void
+
+class EventEmitter {
+  /*
+   * @type {object} events - container to hold key value pairs of events/functions
+   */
+  private events: Record<string, Listener[]>
+
+  /*
+   * @type {object} eventMap - map of available events
+   * For the default eventbus see ./lib/eventMap.ts
+   */
+  private eventMap?: Record<string, any>
+
+  /*
+   * @param {array} eventMap
+   */
+  constructor(eventMap?: Record<string, any>) {
+    /*
+     * @type {object} events - container to hold key value pairs of events/functions
+     */
+    this.events = {}
+    /*
+     * @type {object} eventMap - map of available events
+     */
+    this.eventMap = eventMap
+  }
+
+  /*
+   * on
+   *
+   * @param {string} event - event name
+   * @param {function} listener - callback function
+   */
+  // eslint-disable-next-line id-length
+  on(event: string, listener: Listener): () => void {
+    if (!this.isValid(event)) {
+      return () => {}
+    }
+    if (typeof this.events[event] !== "object") {
+      this.events[event] = []
+    }
+    this.events[event].push(listener)
+
+    return () => this.removeListener(event, listener)
+  }
+
+  /*
+   * removeListener
+   *
+   * @param {string} event - event name
+   * @param {function} listener - callback function
+   */
+  removeListener(event: string, listener: Listener): void {
+    if (typeof this.events[event] === "object") {
+      const idx = this.events[event].indexOf(listener)
+
+      if (idx > -1) {
+        this.events[event].splice(idx, 1)
+      }
+    }
+  }
+
+  /*
+   * emit
+   *
+   * @param {string} event - event name
+   * @param {string|object|boolean} - arbitrary arguments
+   */
+  emit(event: string, ...args: any[]): boolean {
+    if (!this.isValid(event)) {
+      return false
+    }
+    if (typeof this.events[event] === "object") {
+      this.events[event].forEach((listener) => listener.apply(this, args))
+
+      return true
+    }
+
+    return false
+  }
+
+  /*
+   * once
+   *
+   * @param {string} event - event name
+   * @param {function} listener - callback function
+   */
+  once(event: string, listener: Listener): void {
+    if (!this.isValid(event)) {
+      return
+    }
+    const remove = this.on(event, (...args) => {
+      remove()
+      listener.apply(this, args)
+    })
+  }
+
+  /*
+   * isValid
+   *
+   * If an eventMap is present this method checks if the given event exists as
+   * key in the map. This is only done for core events, not for plugins.
+   * @param {string} event - event name
+   */
+  private isValid(event: string): boolean {
+    // Skip validation for plugin-prefixed events
+    if (event.includes("__") && event.includes("--")) {
+      // assume plugin
+      return true
+    }
+
+    // early return if we don't have an eventMap
+    if (!this.eventMap) {
+      return true
+    }
+
+    // throw error if the event is unknown
+    if (!this.eventMap.hasOwnProperty(event)) {
+      throw new Error(
+        `Unkown event passed to eventbus, please check or update: "${event}"`,
+      )
+    }
+
+    // return true if the event exists in the eventMap
+    return true
+  }
+}
+
+export default EventEmitter
+export type { Listener }

package/services/backend/src/core/http/headers.ts

@@ -0,0 +1,30 @@
+import type { FastifyInstance, RouteOptions, FastifySchema } from "fastify"
+import fastifyPlugin from "fastify-plugin"
+import { CommonHeadersSchema } from "../validation/sharedSchemas"
+
+// Properly type the schema object
+type ExtendedSchema = FastifySchema & {
+  headers?: Record<string, unknown>
+}
+
+export default fastifyPlugin(async (fastify: FastifyInstance) => {
+  // Add shared schemas
+  fastify.addSchema({
+    $id: "commonHeaders",
+    ...CommonHeadersSchema,
+  })
+
+  // Add hook to validate headers for all routes
+  fastify.addHook("onRoute", (routeOptions: RouteOptions) => {
+    // Skip if route explicitly opts out of header validation
+    if (routeOptions.skipHeaderValidation) return
+
+    // Merge existing schema with common headers
+    const routeSchema = (routeOptions.schema || {}) as ExtendedSchema
+    routeSchema.headers = {
+      ...(routeSchema.headers || {}),
+      ...CommonHeadersSchema.properties, // Use .properties to get the actual schema object
+    }
+    routeOptions.schema = routeSchema
+  })
+})

package/services/backend/src/core/http/httpService.ts

@@ -0,0 +1,56 @@
+import type {
+  HttpRequestConfig,
+  HttpPluginOptions,
+  HttpService,
+} from "@c/http/httpTypes"
+import type { AxiosRequestConfig } from "axios"
+import type { FastifyInstance } from "fastify"
+import axios from "axios"
+import fastifyPlugin from "fastify-plugin"
+import https from "https"
+
+export default fastifyPlugin(
+  async (fastify: FastifyInstance, options: HttpPluginOptions = {}) => {
+    const client = axios.create({
+      timeout: options.timeout || 30000,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.defaultHeaders,
+      },
+    })
+
+    const createConfig = (
+      config: HttpRequestConfig = {},
+    ): AxiosRequestConfig => {
+      if (config.ignoreSSL) {
+        return {
+          ...config,
+          httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+        }
+      }
+      return config
+    }
+
+    const httpService: HttpService = {
+      get: async <T = any>(url: string, config?: HttpRequestConfig) =>
+        client.get<T>(url, createConfig(config)),
+
+      post: async <T = any>(
+        url: string,
+        data?: any,
+        config?: HttpRequestConfig,
+      ) => client.post<T>(url, data, createConfig(config)),
+
+      put: async <T = any>(
+        url: string,
+        data?: any,
+        config?: HttpRequestConfig,
+      ) => client.put<T>(url, data, createConfig(config)),
+
+      delete: async <T = any>(url: string, config?: HttpRequestConfig) =>
+        client.delete<T>(url, createConfig(config)),
+    }
+
+    fastify.decorate("http", httpService)
+  },
+)

package/services/backend/src/core/http/httpTypes.ts

@@ -0,0 +1,33 @@
+import type { AxiosRequestConfig, AxiosResponse } from "axios"
+
+export interface HttpRequestConfig extends AxiosRequestConfig {
+  ignoreSSL?: boolean
+  timeout?: number
+}
+
+// Limited interface we want to expose
+export type HttpService = {
+  get<T = any>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Promise<AxiosResponse<T>>
+  post<T = any>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<AxiosResponse<T>>
+  put<T = any>(
+    url: string,
+    data?: any,
+    config?: HttpRequestConfig,
+  ): Promise<AxiosResponse<T>>
+  delete<T = any>(
+    url: string,
+    config?: HttpRequestConfig,
+  ): Promise<AxiosResponse<T>>
+}
+
+export interface HttpPluginOptions {
+  timeout?: number
+  defaultHeaders?: Record<string, string>
+}

package/services/backend/src/core/http/request-params.plugin.ts

@@ -0,0 +1,55 @@
+import type { CommonHeadersSchema } from "@c/validation/sharedSchemas"
+import type { Static } from "@sinclair/typebox"
+import type { FastifyRequest } from "fastify"
+import fastifyPlugin from "fastify-plugin"
+import { createRequestParams } from "@/utils/request.utils"
+
+type CommonHeaders = Static<typeof CommonHeadersSchema>
+
+const isExcluded = (url: string) => {
+  const excludedPaths = ["/health", "/metrics"]
+  return excludedPaths.includes(url)
+}
+
+export default fastifyPlugin(async (fastify) => {
+  fastify.addHook("preHandler", async (request: FastifyRequest) => {
+    const routeOptions = request.routeOptions.config
+    request.requestParams = createRequestParams(
+      request as FastifyRequest<{
+        Headers: CommonHeaders
+      }>,
+      routeOptions || {},
+    )
+  })
+  fastify.addHook("onRequest", (request, reply, done) => {
+    done()
+  })
+  fastify.addHook("onRequest", (request, reply, done) => {
+    const url = request.raw.url || ""
+    if (!isExcluded(url)) {
+      request.log.info(
+        { url: request.raw.url, id: request.id },
+        "Received request",
+      )
+    }
+
+    done()
+  })
+
+  fastify.addHook("onResponse", (request, reply, done) => {
+    const url = request.raw.url || ""
+    if (!isExcluded(url)) {
+      request.log.info(
+        {
+          url: request.raw.url,
+          statusCode: reply.statusCode,
+          responseTime: reply.elapsedTime(),
+          id: request.id,
+        },
+        "Request completed",
+      )
+    }
+
+    done()
+  })
+})