App service
Services/Slack Inviter

Slack Inviter service

Application service for self-hosting an invitation page for public Slack communities that already have a working legacy administrator API token, with optional Cloudflare Turnstile protection.

Legacy Slack token required

Requires an existing Slackin-compatible legacy administrator API token. Slack no longer issues these tokens, and ordinary Slack app or bot tokens do not work. Start a deployment only if you already have a working legacy token.

Use it as a versioned stack building block that can build from source, plug into CI/CD, and connect to external providers without hardcoding secrets into the codebase.

On Wodby

How Slack Inviter runs on Wodby

What Wodby sets up for an application that runs on this service. Check it before changing the start command, the port or connection settings in the code.

How the application is started

The image built by the service's Dockerfile starts the application with npm run start, from /usr/src/app. package.json must define a start script.

  • The application must listen on port 3000, on all interfaces. That is the port of the service's HTTP endpoint. The service sets NODE_PORT to that number; it does not set PORT. Read NODE_PORT, or default to 3000.
  • NODE_ENV is development in environments of type dev and production in every other type.

Build

The service's Dockerfile only copies the build context to /usr/src/app. It does not run npm install. Dependencies, and any compiled output, must be produced by the pipeline before the image is built, for example with wodby ci run -- npm ci, so that node_modules is part of what is copied. An image built without node_modules cannot load the application's dependencies.

A pipeline that passes a Dockerfile from the repository (wodby ci build node -f Dockerfile) uses that file instead.

The service declares no volume of its own: files written inside the container are lost when it is replaced.

Linked services

Links to other services reach the application as environment variables. Nothing in the image reads them: the application reads them itself. Do not hardcode hosts or credentials.

LinkVariables
Database (MariaDB, MySQL or PostgreSQL)DB_HOST, DB_PORT, DB_NAME (also DB_DATABASE), DB_USERNAME, DB_PASSWORD, DB_DRIVER (also DB_CONNECTION)
MailSMTP_HOST, SMTP_PORT
Redis or ValkeyREDIS_HOST, REDIS_PORT, REDIS_PASSWORD
OpenTelemetry CollectorOTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_PROTOCOL (http/protobuf), OTEL_EXPORTER_OTLP_HEADERS (the Collector's ingest token)

All links are optional. A variable is present only while its link exists and the linked service is enabled. The mail link carries no credentials. The OpenTelemetry variables are the standard SDK settings: an application or agent that uses an OpenTelemetry SDK exports to the Collector without further configuration; set OTEL_SERVICE_NAME to name the application in traces.

Environment

  • WODBY_HOSTS is a JSON array of the environment's hosts, not a comma-separated string. WODBY_PRIMARY_HOST and WODBY_PRIMARY_URL are the canonical ones for links generated outside a request.
  • WODBY_APP_SERVICE_NAME is this service's host name inside the environment. Other services reach the application at that name on port 3000.
  • WODBY_ENV_TYPE tells a development environment from a production-like one.

In a development workspace

  • The checkout is mounted at /usr/src/app and served as it is on disk.
  • Workspace setup installs dependencies with workspace-node prepare. The package manager is taken from packageManager in package.json, otherwise from the lockfile: pnpm-lock.yaml means pnpm, yarn.lock means Yarn, anything else npm. Installs follow the lockfile exactly (npm ci, --frozen-lockfile, --immutable), with development dependencies. Run it again after changing dependencies.
  • The application is started with the dev script of package.json when there is one, otherwise with start. WORKSPACE_NODE_COMMAND on the service replaces that command.
  • NODE_ENV is always development here, whatever the environment type. PORT is set, to NODE_PORT unless given, and HOST to 0.0.0.0.
  • A saved file is picked up without a restart or a deployment. A dev script is expected to watch the files itself. A start script runs the application once, so the checkout is watched for it: when a file changes, the application is stopped and started again in the same container, within a few seconds. node_modules, .git, .pnpm-store, .next, dist, build and coverage are not watched. A command set with WORKSPACE_NODE_COMMAND is run as it is, without that watcher; WORKSPACE_NODE_WATCH=0 turns the watcher off. For scripts with their own watcher, CHOKIDAR_USEPOLLING, CHOKIDAR_INTERVAL and WATCHPACK_POLLING are set, because a checkout on network storage needs polling. WORKSPACE_POLL_INTERVAL changes the interval, WORKSPACE_POLLING=0 turns this off.
  • node_modules/ and /.pnpm-store/ are kept out of Git status without touching .gitignore.
  • A change to variables or linked services still needs a deployment of the environment.

Check the result

  • curl -s -o /dev/null -w '%{http_code}' "localhost:$NODE_PORT" from the container shows whether the application answers on the expected port.
  • printenv | grep -E '^(DB|SMTP|REDIS)_' | cut -d= -f1 lists the link variables that are present.

Slack Inviter on Wodby

What this service adds to the Node.js service it is based on. The application is the public wodby/slack-inviter project: an invitation page for a Slack community. It is configured entirely through environment variables; the source needs no edits.

Where each variable comes from

SourceVariables
Set by the servicePUBLIC_URL (the environment's primary URL), TURNSTILE_EXPECTED_HOSTNAME (the primary host), TRUST_PROXY (true)
Service settingsSLACK_TEAM (required), COMMUNITY_NAME, COMMUNITY_HEADLINE, COMMUNITY_DESCRIPTION, COMMUNITY_WEBSITE_URL, COMMUNITY_LOGO_URL, COMMUNITY_SUPPORT_URL, COMMUNITY_PRIVACY_URL, SOCIAL_IMAGE_URL, RATE_LIMIT_IP_MAX, RATE_LIMIT_IP_WINDOW_SECONDS, RATE_LIMIT_EMAIL_MAX, RATE_LIMIT_EMAIL_WINDOW_SECONDS
Slack integration (required)SLACK_TOKEN
Cloudflare Turnstile integration (optional)TURNSTILE_SITE_KEY, TURNSTILE_SECRET_KEY

Change the page's texts, links and limits through the service's settings, and the token and keys through the attached integrations. Do not put them in the repository or in a .env file.

What the application requires

  • It refuses to start without SLACK_TEAM and SLACK_TOKEN, and without PUBLIC_URL unless NODE_ENV is development or test.
  • SLACK_TEAM is the workspace subdomain only, not a URL.
  • PUBLIC_URL must be an origin only: scheme and host, no path.
  • Turnstile verification is on when both Turnstile variables are present. Only one of them makes the application refuse to start.
  • COMMUNITY_LOGO_URL and SOCIAL_IMAGE_URL accept an HTTPS URL or a root-relative path.
  • A failed start reports the offending variable by name in the container's log.

Running

  • The application listens on NODE_PORT, which the Node.js service sets to 3000. It has no dependencies to install.
  • /healthz and /.healthz answer the health check.
  • The rate limiter keeps its counters in the memory of one process. They are not shared between replicas and are reset by a restart.
  • The service uses none of the database, mail or Redis variables of the Node.js service.

Overview

Technical profile and packaging

This page shows how Slack Inviter is packaged and versioned as a Wodby service, what it exposes at runtime, and which source artifacts it builds on.

Service type

App service

Versions

26, 24, 22

Ports and protocols

3000/HTTP

Labels

slack, node, inviter, node

Stacks

Use it inside ready-made stacks or your own

These public stacks already include Slack Inviter as part of their default service model. You can start there and customize the stack, or compose your own stack around the same building block.

CI/CD

Build from source and ship changes without extra glue work

Slack Inviter can build from source as part of a stack. Start from a compatible public boilerplate or connect your repository and keep CI/CD and image storage inside the same Wodby workflow.

Slack Inviter

Start from a working boilerplate instead of wiring the build process from scratch.

wodby/slack-inviter

Git providers

Connect repositories from supported Git providers when this service should build from your own codebase.

CI providers

Wodby CI is the default path, but external CI providers can fit the same build and release workflow when that suits your team better.

Container registries

Keep built images in Wodby Registry by default or store them in another registry without changing how the service is built.

Runtime wiring

Reuse connectivity, storage, and runtime defaults

This service can expose ports, connect to other services, attach persistent storage, and define runtime defaults that become reusable inside stacks rather than being rebuilt case by case.

Endpoints

3000/HTTP

Technical domains

HTTP endpoints from this service can use technical domains with auto-renewed TLS certificates on Wodby.

Settings

13 settings can be overridden per environment.

Service links

These links define which other services can connect to Slack Inviter when it is used inside a stack.