@raclettejs/core 0.1.25 → 0.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raclettejs/core",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "racletteJS core package",
   "repository": "https://gitlab.com/raclettejs/core",
   "author": "Pacifico Digital Explorations GmbH <info@raclettejs.com>",
@@ -37,7 +37,8 @@
     "src/types.ts",
     "LICENSE.md",
     "CONTRIBUTING.md",
-    "raclette.default.config.yaml"
+    "raclette.default.config.yaml",
+    "templates"
   ],
   "exports": {
     ".": {
@@ -78,7 +79,7 @@
     "@emnapi/core": "1.9.2",
     "@emnapi/runtime": "1.9.2",
     "@eslint/js": "9.35.0",
-    "@raclettejs/types": "^0.1.25",
+    "@raclettejs/types": "^0.1.27",
     "@types/fs-extra": "11.0.4",
     "@types/js-yaml": "4.0.9",
     "@types/node": "25.5.0",

package/services/backend/src/core/config/configService.ts

@@ -126,7 +126,7 @@ export class ConfigService {
   public getFastifyRateLimits() {
     const config = this.getConfig()
 
-    return config?.accessRateLimit ?? { max: 1000, timeWindow: "1 minute" }
+    return config?.accessRateLimit ?? { max: 1000, timeWindow: 60000 }
   }
   // Helper to check if a specific auto-send feature is enabled
   // Default to true unless explicitly set to false

package/services/backend/src/modules/hooks/rate-limiter.ts

@@ -6,16 +6,5 @@ import configService from "@c/config/configService"
 export default fastifyPlugin(async (fastify: FastifyInstance) => {
   const opts = configService.getFastifyRateLimits()
   fastify.log.info("Fastify Ratelimiter with opts " + JSON.stringify(opts))
-  await fastify.register(rateLimit, opts)
-  fastify.setNotFoundHandler(
-    {
-      preHandler: fastify.rateLimit({
-        max: 4,
-        timeWindow: 500,
-      }),
-    },
-    function (request, reply) {
-      reply.code(404).send({ why: "you do dat?" })
-    },
-  )
+  await fastify.register(rateLimit, { ...opts, global: true })
 })

package/services/frontend/src/core/lib/data/dataApi.ts

@@ -42,6 +42,7 @@ const $writeDataApi = (
       if (options.responseType === "stream") {
         return writeData(actionId, operationDefinition, queryParams, options)
       }
+
       isLoadingSubject$.next(true)
       const resultData = await writeData(
         actionId,
@@ -49,8 +50,7 @@ const $writeDataApi = (
         queryParams,
         options,
       ).catch((e) => {
-        const errorObj = e
-        errorSubject$.next(errorObj)
+        errorSubject$.next(e.response)
         isLoadingSubject$.next(false)
       })
       responseSubject$.next(resultData?.response)

package/services/frontend/src/core/lib/data/queryApi.ts

@@ -86,8 +86,7 @@ export const $queryApi = (
         queryParams,
         options,
       ).catch((e) => {
-        const errorObj = e
-        errorSubject$.next(errorObj)
+        errorSubject$.next(e.response)
       })
       responseSubject$.next(resultData?.response)
       if (callbacks[actionId] && typeof callbacks[actionId] === "function") {

package/services/frontend/src/core/store/state.ts

@@ -122,26 +122,6 @@ const storePatterns = {
     uuid: false,
     version: "0.0.0",
   },
-  page: {
-    // the icon to be displayed in the page navigation
-    icon: false,
-    // this will determine if we always scroll to the last page position or
-    // to the top whenever we enter this page
-    scrollTop: false,
-    // The title of the page if i18n from db
-    title: "",
-    // The title of the page if i18n key is handled in frontend
-    titleI18n: "",
-    // grid config for a page
-    grid: configPatterns.grid,
-    // the array containing the configs for the 1-n slots
-    slots: [[]],
-    // the name of the route configured in the vue router
-    routeName: false,
-    // The uuid of other unique identifier for the page within the application context
-    uuid: false,
-    version: "0.0.0",
-  },
   widget: {
     // The title of the page if i18n from db
     title: "",
@@ -152,30 +132,15 @@ const storePatterns = {
     uuid: false,
     // the type of widget which represents a folder name under widgets and a config
     name: false,
-    // a deeper abstractation level for widgets which are used as tools.
-    // ie. type:''add' create a folder called 'add' and create a default.vue
-    // or FACE.vue containing your add logic for a given widget
+    // any working state we want to have available in the store and not just the component
     workingState: {},
+    // any acutal config we provide to the widget
+    config: {},
+    // any data the widget want's to provide to other widgets/plugins/core such as serializers, connection hooks to other modules etc
+    public: {},
     version: "0.0.0",
-  },
-  tools: {
-    // The title of the page if i18n from db
-    title: "",
-    // The title of the page if i18n key is handled in frontend
-    titleI18n: "",
-    // an array of route names this tool should be visible on. If array is empty, it will be visible everywhere
-    pages: [],
-    // an icon to be displayed in the tool wrapper
-    icon: false,
-    // a uniqe identifier for the tool
-    uuid: false,
-    // the widget which should serve as the functionallity of the tool
-    widget: false,
-    version: "0.0.0",
+    pluginKey: "",
   },
 }
 
-// add the widget store pattern to the tool
-storePatterns.tools.widget = storePatterns.widget
-
 export { loadingHold, applicationState, configPatterns, storePatterns }

package/templates/backend.Dockerfile

@@ -0,0 +1,31 @@
+FROM node:24.4-alpine3.21
+WORKDIR /app
+
+# add bash since alpine doesn't come with a shell
+RUN apk update && apk add bash curl {{config.services.backend.installPackages}} {{.}} {{/config.services.backend.installPackages}}
+
+COPY backend/package.json backend/yarn.lock ./
+COPY backend/raclette.config.js ./
+
+ARG NODE_ENV={{environment}}
+
+
+# make sure our raclette packages are being resolved by adding a symlink to handle nodes module resolution
+RUN mkdir -p /app/node_modules/@raclettejs/core
+RUN ln -sf /app/src /app/node_modules/@raclettejs/core/backend
+
+COPY ./dist/check-dependencies.sh /app/
+RUN chmod +x /app/check-dependencies.sh
+
+# copy everything else that is not ignored (see .dockerignore)
+COPY ./virtual/backend ./
+
+# set default values
+ENV PORT 3000
+
+# set port
+EXPOSE 3000
+EXPOSE 9229
+
+# default command
+CMD ["yarn", "run", "{{#environment}}build{{/environment}} {{^environment}}dev{{/environment}} "]

package/templates/build.yml

@@ -0,0 +1,34 @@
+entryPoints:
+  - ./src/cli.ts
+  - ./src/index.ts
+bundle: true
+platform: node
+target: node20
+outdir: ./dist
+format: esm
+banner:
+  js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);"
+external:
+  # External packages that shouldn't be bundled
+  - fastify
+  - mongodb
+  - mongoose
+  - redis
+  - chokidar
+  - fs-extra
+  # Node.js built-ins
+  - fs
+  - path
+  - child_process
+  - os
+  - url
+  - util
+  - events
+  - stream
+  - crypto
+  # Add any native modules you're using
+  - fsevents
+loader: 
+  .node: file
+sourcemap: true
+minify: false

package/templates/docker-compose.yml

@@ -0,0 +1,161 @@
+services:
+  mongodb:
+    container_name: ${RACLETTE_MONGODB_CONTAINERNAME:-raclette-mongodb}
+    image: mongo:8.2
+    restart: unless-stopped
+    ports:
+      - 127.0.0.1:${RACLETTE_MONGODB_PORT:-27017}:27017
+    volumes:
+      - ${RACLETTE_MONGODB_VOLUME:-raclette-mongodb}:/data/db
+      - >-
+        ${RACLETTE_MONGODB_CONFIG_VOLUME:-playground-mongodb-config}:/data/config
+    networks:
+      - raclette_shared
+    healthcheck:
+      test:
+        - CMD
+        - mongosh
+        - '--eval'
+        - db.adminCommand('ping')
+      interval: 10s
+      timeout: 30s
+      retries: 20
+  cache:
+    container_name: ${RACLETTE_CACHE_CONTAINERNAME:-raclette-cache}
+    image: valkey/valkey:9.0-alpine
+    ports:
+      - 127.0.0.1:${RACLETTE_CACHE_PORT:-6379}:6379
+    volumes:
+      - ${RACLETTE_CACHE_VOLUME:-raclette-cache}:/data
+    networks:
+      - raclette_shared
+    healthcheck:
+      test:
+        - CMD
+        - valkey-cli
+        - ping
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    command: valkey-server --save ""
+  backend:
+    container_name: ${RACLETTE_SERVER_CONTAINERNAME:-playground-backend}
+    build:
+      context: .
+      dockerfile: ./backend.Dockerfile
+      args:
+        NODE_ENV: development
+    command: yarn run dev:inspect
+    environment:
+      - NODE_ENV=${NODE_ENV:-development}
+      - DISABLE_PLUGIN_LOGS=${RACLETTE_DISABLE_PLUGIN_LOGS:-false}
+      - >-
+        SERVER_TOKEN_SECRET=${RACLETTE_SERVER_TOKEN_SECRET:-thisshouldbesetforproduction}
+      - RACLETTE_FRONTEND_URLS=${RACLETTE_FRONTEND_URLS:-}
+      - >-
+        MONGO_HOST=${RACLETTE_MONGODB_HOST:-mongodb://mongodb:${RACLETTE_MONGODB_PORT:-27017}/${RACLETTE_MONGODB_DATABASE:-raclette}}
+      - >-
+        CACHE_URL=${RACLETTE_CACHE_URL:-redis://cache:${RACLETTE_CACHE_PORT:-6379}}
+      - RACLETTE_DEBUG_MODE=true
+      - RACLETTE_APP_PATH=/home/shookie/core-dev/@raclettejs/playground
+    volumes:
+      - yarn-cache:/usr/local/share/.cache/yarn
+      - playground-backend_node_modules:/app/node_modules
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/backend/src:/app/src
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/plugins:/app/src/appPlugins
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/backend/raclette.config.js:/app/raclette.config.js
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/backend.yarn.lock:/app/yarn.lock
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/dist/check-dependencies.sh:/app/check-dependencies.sh
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/backend/package.json:/app/package.json
+    ports:
+      - ${RACLETTE_SERVER_PORT:-8082}:3000
+      - '9229:9229'
+    networks:
+      - raclette_shared
+    depends_on:
+      mongodb:
+        condition: service_started
+      cache:
+        condition: service_healthy
+    healthcheck:
+      test:
+        - CMD
+        - curl
+        - '-f'
+        - http://0.0.0.0:3000/health
+      interval: 10s
+      timeout: 30s
+      retries: 10
+    entrypoint:
+      - /app/check-dependencies.sh
+  frontend:
+    container_name: ${RACLETTE_CLIENT_CONTAINERNAME:-playground-frontend}
+    build:
+      context: .
+      dockerfile: ./frontend.Dockerfile
+      args:
+        NODE_ENV: ${NODE_ENV:-development}
+      target: ${NODE_ENV:-development}
+    command: yarn dev
+    depends_on:
+      backend:
+        condition: service_healthy
+    environment:
+      - NODE_ENV=${NODE_ENV:-development}
+      - RACLETTE_DEBUG_MODE=${RACLETTE_DEBUG_MODE:-true}
+      - >-
+        RACLETTE_SERVER_BASE_URL=${RACLETTE_SERVER_BASE_URL:-http://localhost:${RACLETTE_SERVER_PORT:-8082}}
+      - >-
+        RACLETTE_SOCKET_URL=${RACLETTE_SOCKET_URL:-http://localhost:${RACLETTE_SERVER_PORT:-8082}}
+      - RACLETTE_DEBUG_MODE=true
+      - RACLETTE_APP_PATH=/home/shookie/core-dev/@raclettejs/playground
+    volumes:
+      - yarn-cache:/usr/local/share/.cache/yarn
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/frontend/src:/app/src
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/backend/src/shared:/app/src/shared
+      - playground-frontend_node_modules:/app/node_modules
+      - /home/shookie/core-dev/@raclettejs/playground/plugins:/app/src/plugins
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/virtual/backend/src/corePlugins:/app/src/corePlugins
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/frontend/raclette.config.js:/app/raclette.config.js
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/frontend.yarn.lock:/app/yarn.lock
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/dist/check-dependencies.sh:/app/check-dependencies.sh
+      - >-
+        /home/shookie/core-dev/@raclettejs/playground/.raclette/frontend/package.json:/app/package.json
+    ports:
+      - ${RACLETTE_CLIENT_PORT:-8081}:8081
+    networks:
+      - raclette_shared
+    healthcheck:
+      test:
+        - CMD
+        - curl
+        - '-f'
+        - http://0.0.0.0:8081/
+      interval: 10s
+      timeout: 30s
+      retries: 10
+    entrypoint:
+      - /app/check-dependencies.sh
+volumes:
+  yarn-cache:
+    driver: local
+  raclette-public-shared: null
+  {{#volumes}}
+    {{entry}}
+  {{/volumes}}
+networks:
+  raclette_shared:
+    external: true
+    name: raclette_shared

package/templates/frontend.Dockerfile

@@ -0,0 +1,49 @@
+FROM node:24-alpine3.21 AS build
+WORKDIR /app
+
+RUN apk update && apk add bash curl {{#config.services.frontend.installPackages}} {{.}} {{/config.services.frontend.installPackages}}
+
+# Copy package files first for better caching
+COPY frontend/package.json frontend/yarn.lock ./
+COPY frontend/raclette.config.js ./
+
+ARG NODE_ENV={{environment}}
+
+# Copy source files - we'll handle development overrides through volumes
+COPY ./virtual/frontend/ ./
+
+COPY ./dist/check-dependencies.sh /app/
+RUN chmod +x /app/check-dependencies.sh
+
+RUN rm -rf ./src/shared
+
+# Now copy the actual shared folder - be explicit with the path
+COPY virtual/backend/src/shared/ ./src/shared/
+
+# Ports
+ENV PORT {{config.services.frontend.port}}
+EXPOSE {{config.services.frontend.port}}
+
+# Add development target
+FROM build AS development
+CMD ["yarn", "run", "dev"]
+
+# ----------------------------------------------------------------
+# 2. production stage
+# Here we will use a new docker image, which is only the web server
+FROM nginx:stable-alpine AS production
+WORKDIR /app
+
+# Copy nginx config as a template
+COPY frontend/provision/nginx.conf /etc/nginx/conf.d/default.conf.template
+
+COPY --from=build app/dist /usr/share/nginx/html
+COPY frontend/provision/entrypoint.sh /docker-entrypoint.d/entrypoint.sh
+
+# Make sure the entrypoint is executable
+RUN chmod +x /docker-entrypoint.d/entrypoint.sh
+
+ENV PORT 80
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]

package/templates/fs.yml

@@ -0,0 +1,73 @@
+# this defines the contents of the raclette app directory named by config.root (usually .raclette)
+# the files in there are either generated at build time or linked from the sources
+# these settings rarely if ever change, so they are outside the general raclette.config.yaml
+# during development almost everything in there is mounted as volumes to the different running containers
+# in production builds the contents become part of the image
+
+# almost the only reason this exists is so the development docker containers can do hot-reload
+# without messing up the workspaces and git repo
+# the hot-reload itself is of course handled by node, vite or tsx
+# but the changes in the repo need to be passed on to the volumes
+# this is done by creating hardlinks on startup
+# and watching the repo itself for relevant additions and deletions
+
+
+patterns:
+  # can be used in vfs mappings, but mainly is used in watcher file selection
+  ext:     ["**/*.vue", "**/*.ts", "**/*.js", "**/*.json", "**/*.css", "**/*.scss"]
+  pkg:     ["**/package.json", "**/yarn.lock"] # changes here require new install anyway
+  # always added when globbing, config.root is also always added
+  ignore:  ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/.prettierrc", "**/eslint.config.js"]
+
+
+mappings:
+# this defines how files are processed, whether they are watched or not
+# remember, all watched files are hard linked, this just defines where from and where to
+# the mappings are processed in order, and when a later mapping tries to link to the same location, that file will be ignored
+# 
+# src: files can come from different source paths, the most common being
+#      1. generated files from the raclette root directory, paths starting with "/"
+#         generated files are not watched
+#      2. the raclette core package, paths starting with ".", this is the default
+#      3. paths defined in environment variables, starting with "$", the default being "RACLETTE_APP_PATH"
+#      4. any other relative path is from the current application directory, the default is ""
+# get: this selects the files relative to the source that need to be gotten
+#      - you use globby syntax here for pattern matching
+#      - a string that matches a key in patterns above will splice the pattern into the glob list
+#      - default is [ '**' ], i.e. recursivly everything
+# for dst:
+#    - always relative to vfs root, i.e. "." is the default, which is "$config.root/virtual/"
+#    - the final link target is always the join of dst / selected-file
+#    - can be a list for multiple destinations
+#    - when the get list is a single file, and dst is not "." and does not end in "/", the file will be renamed
+  - src: services/
+  - get: src/types.ts
+    dst: [backend/types/index.ts, frontend/types/index.ts]
+  - src: ./services/
+  - src: /
+    get: [ frontend/*, backend/* ]
+  - get: bin/check-dependencies.sh           # copies from core/bin into $config.root/dist/
+    dst: ../dist/check-dependencies.sh
+  - src: i18n
+    dst: frontend/src/orchestrator/i18n/app/
+  - src: workbench/i18n
+    dst: frontend/src/orchestrator/i18n/workbench/
+  - src: shared
+    dst: [ frontend/src/shared/app/, backend/src/shared/app/ ]
+  - src: $/shared/
+    dst: [ backend/src/shared/app/,  backend/src/shared/app/ ]
+
+# these are the chokidar watcher options that get passed along as is (ignored string compiled as RegExp)
+watcher:
+  followSymlinks: false
+  ignoreInitial: true
+  ignored: ^node_modules|/node_modules$|^dist|/dist$|^\\.git|/\\.git$
+
+volumes:
+# these are added to the volumes of the respective services in the compose files
+# since later volumes override earlier volumes, the order here is important
+# for production builds this also defines the order of COPY operations for image creation
+# volume sources can be the same as mapping sources, with one exception:
+# there can't be any direct mounting of core based paths, instead there are vfs based paths
+# i.e. paths starting with "." are relative to "$config.root/virtual"
+- 

package/templates/raclette.config.workbench.yaml

@@ -0,0 +1,61 @@
+defineRacletteConfig:
+  name: "raclette-dev"
+
+  # Configure services
+  services:
+    frontend:
+      enabled: true
+      port: 8081
+
+    backend:
+      enabled: true
+      port: 8082
+      enableDebug:  {{process.env.ENABLE_DEBUG}}
+      installPackages: ["imagemagick", "font-overpass", "font-dejavu"]
+  
+    mongodb:
+      name: "raclette-mongodb"
+      enabled: true
+      port: 27017
+      volume: "raclette-mongodb"
+      databaseName: "raclette"
+
+    cache:
+      name: "raclette-cache"
+      volume: "raclette-cache"
+      enabled: true
+      port: 6379
+
+    workbench:
+      enabled: true
+      debugPort: 9228
+      frontendPort: 8083
+      backendPort: 8084
+      withLogs: false
+      
+  # list your installed plugins
+  # make sure they are listed in your package.json
+  # Environment-specific configuration
+  env:
+    development:
+      RACLETTE_DEBUG_MODE: true
+    production:
+      NODE_ENV: "production"
+
+  # Frontend framework configuration
+  frontend:
+    meta:
+      title: "Dev-Setup"
+    i18n:
+      locales: ["tl-TL", "en-EU", "de-DE"]
+    framework: "vue"
+    vue:
+      plugins: ["vue-router"]
+  workbench:
+    frontend:
+      i18n:
+        # explicitly set enabled languages for the workbench
+        locales: ["tl-TL", "en-EU", "de-DE"]
+  eslint:
+    useRecommended: false
+

package/templates/raclette.config.yaml

@@ -0,0 +1,59 @@
+name: "raclette-dev"
+root: ".raclette"
+
+services:
+  frontend:
+    enabled: true
+    port: 8081
+
+  backend:
+    enabled: true
+    port: 8082
+    enableDebug:  {{process.env.ENABLE_DEBUG}}
+    installPackages: []
+
+  mongodb:
+    name: "raclette-mongodb"
+    enabled: true
+    port: 27017
+    volume: "raclette-mongodb"
+    databaseName: "raclette"
+
+  cache:
+    name: "raclette-cache"
+    volume: "raclette-cache"
+    enabled: true
+    port: 6379
+
+  workbench:
+    enabled: true
+    debugPort: 9228
+    frontendPort: 8083
+    backendPort: 8084
+    withLogs: false
+
+# list your installed plugins
+# make sure they are listed in your package.json
+# Environment-specific configuration
+env:
+  development:
+    RACLETTE_DEBUG_MODE: true
+  production:
+    NODE_ENV: "production"
+
+# Frontend framework configuration
+frontend:
+  meta:
+    title: "Dev-Setup"
+  i18n:
+    locales: ["tl-TL", "en-EU", "de-DE"]
+  framework: "vue"
+  vue:
+    plugins: ["vue-router"]
+workbench:
+  frontend:
+    i18n:
+      # explicitly set enabled languages for the workbench
+      locales: ["tl-TL", "en-EU", "de-DE"]
+eslint:
+  useRecommended: false

package/templates/shims.vue.d.ts

@@ -0,0 +1,5 @@
+declare module "*.vue" {
+  import { DefineComponent } from "vue"
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}