• Meteor CLI must be installed: curl https://install.meteor.com/ | sh
• MongoDB 6.x or 7.x must be available (local or Atlas)
• Node.js 20.x LTS is required (Meteor pins the version internally)
• For the Rspack/webpack jade loader (npm-packages/meteor-jade-loader), the loader resolves Blaze/Spacebars compiler packages at runtime; those must be available via the Meteor package system, not npm directly.

Project setup

1. Clone / drop source: Place source/ at your project root or a subdirectory. If subdirectory, add a root package.json that symlinks or workspaces to source/.

2. Install Meteor: Run curl https://install.meteor.com/ | sh and confirm meteor --version matches the .meteor/release file inside source/.

3. Install npm deps: Inside source/, run:

   cd source
   meteor npm install
   

4. Configure environment: Copy source/settings.json to source/settings.local.json and fill in:

   {
     "public": { "CARD_OPENED_WEBHOOK_ENABLED": false },
     "MAIL_URL": "smtp://user:pass@smtp.example.com:587",
     "MONGO_URL": "mongodb://localhost:27017/wekan"
   }
   

5. Set environment variables:

   export MONGO_URL=mongodb://localhost:27017/wekan
   export ROOT_URL=http://localhost:4000
   export PORT=4000
   

6. Run:

   meteor run --settings settings.local.json
   

7. Rspack build (for non-Meteor bundling of client assets only):

   npx rspack build --config rspack.config.js
   

   The local npm packages under npm-packages/ must be resolvable; add them to package.json as file: references.

8. TypeScript / Babel: WeKan is plain JS. No tsconfig is needed unless you add TypeScript on top. Babel is used internally via @babel/parser; no separate .babelrc is required for running via Meteor.

Public API

TAPi18n

import { TAPi18n } from '/imports/i18n/index.js';

interface TAPi18n {
  init(): Promise<void>;
  __( key: string, ...args: any[] ): string;
}

TAPi18n is the internationalization singleton. Call TAPi18n.init() once inside Meteor.startup (already wired in imports/i18n/index.js). Use TAPi18n.__('key') anywhere in templates or JS to look up a translated string. Do not call init() more than once; the module guards against double initialization.

getGlobal

// npm-packages/meteor-globals-client/index.js
function getGlobal(packageName: string, globalName?: string): any;

getGlobal is a client-safe shim for reading Meteor package globals at runtime without pulling in Node.js built-ins. Use it when you need access to a Meteor package export (e.g., getGlobal('aldeed:simple-schema', 'SimpleSchema')) from inside a browser-facing module. Returns undefined safely if the package is not loaded.

checkMeteor

function checkMeteor(): boolean;

Returns true unconditionally in the client shim (npm-packages/meteor-globals-client). Used as a guard in @wekanteam/meteor-reactive-cache to skip server-only initialization paths when running in a browser or test environment. Useful when writing isomorphic utilities that depend on Meteor being present.

meteorJadeLoader (Rspack/webpack loader)

// npm-packages/meteor-jade-loader/index.js
// webpack/rspack loader — no named export; referenced by path in config
function meteorJadeLoader(this: LoaderContext, source: string): string;

A Rspack/webpack loader that compiles .jade Blaze templates to JavaScript. Wire it in rspack.config.js for any .jade file. It detects .tpl.jade (template mode) vs. plain .jade (file/body mode) automatically and emits Template.__checkName / new Template(...) registration code.

Working examples

Scenario - Bootstrap i18n in a Meteor startup hook

You want to add translated strings to a server-side method or a client component using the shared i18n module.

// server/myFeature.js  (or client/myFeature.js — isomorphic)
import { Meteor } from 'meteor/meteor';
import { TAPi18n } from '/imports/i18n/index.js';

Meteor.startup(async () => {
  // TAPi18n.init() is already called by imports/i18n/index.js on startup.
  // Just use __ directly after startup completes.
  const label = TAPi18n.__('due-date'); // key from imports/i18n/data/en.i18n.json
  console.log('Translated label:', label);
});

Scenario - Reading a Meteor package global from a browser module

You are writing a client utility that conditionally uses a Meteor package but must not crash if it is absent.

// client/lib/myUtil.js
import { getGlobal, checkMeteor } from '/npm-packages/meteor-globals-client/index.js';

export function getSimpleSchema() {
  if (!checkMeteor()) {
    throw new Error('Not running inside Meteor');
  }
  // Returns the SimpleSchema constructor exposed by the Atmosphere package
  return getGlobal('aldeed:simple-schema', 'SimpleSchema');
}

export function getBlazeTemplate(name: string) {
  const Template = getGlobal('blaze', 'Template');
  return Template ? Template[name] : null;
}

Scenario - Registering the jade loader in Rspack config

You want to bundle WeKan client components via Rspack outside the standard Meteor build.

// rspack.config.js  (extend or replace the existing one in source/)
const path = require('path');

module.exports = {
  entry: './client/main.js',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'bundle.js',
  },
  module: {
    rules: [
      {
        test: /\.jade$/,
        use: [
          {
            // Point at the local package directly
            loader: path.resolve(__dirname, 'npm-packages/meteor-jade-loader/index.js'),
          },
        ],
      },
      {
        test: /\.css$/,
        use: ['style-loader', 'css-loader'],
      },
    ],
  },
  resolve: {
    alias: {
      // Remap meteor/ imports to stubs when running outside Meteor
      'meteor/meteor': path.resolve(__dirname, 'stubs/meteor.js'),
    },
  },
};

File walkthrough

• client/main.js - Client entry point; imports collection helpers, all styles, then all application code in explicit order.
• client/features/main.js - Aggregates all Blaze jade templates, JS controllers, and CSS for main UI features (header, popup, editor, spinners, etc.).
• imports/i18n/index.js - Exports TAPi18n and calls TAPi18n.init() inside Meteor.startup; the canonical i18n bootstrap.
• npm-packages/meteor-globals-client/index.js - Client-safe shim for @wekanteam/meteor-globals; exports getGlobal, checkMeteor, ensureDependency, ensureDependencies.
• npm-packages/meteor-jade-loader/index.js - Rspack/webpack loader that compiles .jade Blaze templates to JS; auto-detects template vs. body mode.
• models/ - MongoDB collection schemas and helpers for all domain entities (boards, lists, cards, users, swimlanes, etc.).
• server/ - Meteor server publications, methods, REST API routes, and server-only utilities.
• migrations/ - Sequential database migration scripts run at startup via percolate:migrations.
• openapi/ - YAML/JSON OpenAPI 3.x specs describing the WeKan REST API endpoints.
• packages/ - Bundled Atmosphere packages that are not available on the public Atmosphere registry.
• public/ - Static assets served directly: fonts, favicons, PWA manifest.
• config/ - App-level configuration loaded at startup (OAuth providers, feature flags).
• rspack.config.js - Rspack bundler configuration for client-side asset compilation outside Meteor.
• docker-compose.yml - Canonical production deployment: wekan-app + wekan-db (MongoDB) services.
• settings.json - Template for Meteor --settings file; contains SMTP, S3, LDAP, and OAuth keys.

Common pitfalls and fixes

• meteor/ imports fail in plain Node/Rspack: Meteor package imports (meteor/meteor, meteor/blaze) don't resolve outside the Meteor build system. Fix: add webpack/rspack aliases pointing to stub files for each meteor/* package you need.
• SimpleSchema used on client crashes: imports/collectionHelpers notes that SimpleSchema is server-only. Fix: guard any schema usage with Meteor.isServer or use getGlobal from the client shim instead.
• TAPi18n.init() called before Meteor.startup: Translations won't load. Fix: always call or await TAPi18n.init() inside Meteor.startup(async () => { ... }) as shown in imports/i18n/index.js.
• Jade loader can't find Spacebars compiler: The loader calls require('./lib/jade-compiler') which expects Spacebars/HTML packages available at build time. Fix: run meteor npm install inside source/ before invoking Rspack so the local node_modules are populated.
• MongoDB connection drops causing data corruption: WeKan's README explicitly warns that running out of disk space corrupts MongoDB. Fix: set disk usage alerts and ensure MONGO_URL points to a replica set with journaling enabled.
• Wrong Node.js version: Meteor embeds its own Node.js but if you run scripts directly the system Node must be 20.x. Fix: use nvm use 20 or pin engines.node in your root package.json.

Vibe-coding prompt template

I have a local copy of the WeKan Open Source Kanban source at `./source/`
and a USAGE.md integration guide at `./USAGE.md`.
The upstream package is `user@example.com`.

My existing project is a Node.js/Express backend (or Meteor app).

Please help me integrate WeKan step by step:

1. Read USAGE.md and source/package.json to understand all required dependencies.
2. Install all runtime npm dependencies listed in USAGE.md into my project.
3. Wire the `source/imports/i18n/index.js` TAPi18n export into my startup sequence,
   following the pattern in USAGE.md "Bootstrap i18n" example.
4. Configure rspack.config.js (using source/npm-packages/meteor-jade-loader) to
   bundle the client components from source/client/main.js.
5. Set up environment variables MONGO_URL, ROOT_URL, PORT, and a settings.json
   based on source/settings.json.
6. Show me how to use getGlobal from source/npm-packages/meteor-globals-client
   to safely access a Meteor package export in a browser module.
7. Identify any meteor/ import aliases I need to stub for non-Meteor bundling.

Refer only to exports and patterns visible in source/ and described in USAGE.md.
Do not invent APIs.

License and credit

WeKan is released under the MIT License. See source/LICENSE for the full text.

Upstream project: WeKan on GitHub — user@example.com. Maintained by the WeKan Team; community translations hosted at Transifex.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

전체 설치 가이드와 연동 프롬프트는 구매 후 열람할 수 있습니다.

Automation, Utilities & Developer Tools

US$6