Taqnix POS Terminal documentation

It is made for cafés, shops and restaurants that run their sales on Odoo 19, and for integrators who set it up for them (one purchase for each client company). Chapters 1 to 7 get it running, 8 to 21 are daily use, 22 to 24 are for developers, and 25 to 30 cover security, what was and was not verified, troubleshooting, updates and support.

The pictures come from a demo shop, Harbor Café & Market (US dollars, Dearborn MI) with two points of sale. Main Shop is retail and café: prices shown with tax, cash rounded to 0.05, the loyalty programme Harbor Rewards and the promo code SUMMER10. Harbor Restaurant has the floors Ground floor and Terrace, a Kitchen printer and a Bar printer, and shows prices without tax. The cashier is Sara Haddad, a plain Point of Sale user. The Odoo address on the pictures is a local test server: you type the address of your own Odoo.

Odoo is a trademark of Odoo S.A. This product is not made or endorsed by Odoo S.A.

Built with Next.js 16, React 19, TypeScript, Tailwind CSS 4, IndexedDB through Dexie, Zustand and Zod.

Option 1: the ready-to-run web app. Nothing to install or build.

1. Install Node.js 20.9 or newer from nodejs.org (node -v shows the version you have).
2. Unzip the package, then unzip taqnix-pos-terminal-webapp.zip in it. The folder taqnix-pos-terminal-webapp is the finished application.
3. Open a terminal (Command Prompt on Windows) in that folder and start it with the address of your Odoo: sh start.sh https://erp.example.com on macOS and Linux, start.bat https://erp.example.com on Windows.
4. Open http://localhost:3000 in Chrome or Edge and connect the terminal to Odoo (chapter 6). Stop it with Ctrl+C.

# macOS and Linux, in the folder taqnix-pos-terminal-webapp
sh start.sh https://erp.example.com
# Windows (Command Prompt, or double-click start.bat)
start.bat https://erp.example.com
# another port; every option
sh start.sh https://erp.example.com --port 3100
sh start.sh --help
# the same without the launcher script
node run.cjs https://erp.example.com

The launcher checks the Node.js version, adds the Odoo address you type to POS_ALLOWED_ORIGINS, reads .env (copy .env.example to .env to keep your settings) and says so when the port is taken. The folder has its own README.txt too.

It listens only on this computer (127.0.0.1) unless you say otherwise. That is enough to try it, and for a till on the same computer: http://localhost counts as a secure address, so the app installs and works offline. For tills on other devices start it with --host 0.0.0.0 (or POS_HOST=0.0.0.0) and put HTTPS in front of it (below). To have it start with the computer and restart after a crash, run node run.cjs with a process manager you already use (systemd, pm2, Windows Task Scheduler).

Option 2: build it from the source code. Use it when you change the app or want to build it on your own server.

1. Unzip the package, then unzip taqnix-pos-terminal.zip and open a terminal in src/pos-terminal (the folder with package.json).
2. Run npm ci, then copy .env.example to .env and set POS_ALLOWED_ORIGINS to the address of your Odoo.
3. Run npm run build (it also writes the service worker and the list of licences), then npm start. The server listens on port 3000; use npm start -- -p 3100 to change it.
4. Put a TLS front in front of the port (below), then open the HTTPS address in Chrome or Edge on the till.

npm ci
npm run dev            # development server on http://localhost:3000 (permissive proxy defaults)
npm run build          # production build + service worker (scripts/make-sw.mjs) + licences file
npm start              # production server (NODE_ENV=production), port 3000 (-p to change)
POS_STANDALONE=1 npm run build   # .next/standalone, used by the Dockerfile
npm run pack:webapp    # after that build: a ready-to-run folder in webapp-dist/, like the one in the package
docker compose up -d   # build + run with the settings of .env (copy .env.example)

The server reads its settings from environment variables, in .env or in the environment of the process:

POS_ALLOWED_ORIGINS=https://erp.example.com
# POS_ALLOW_ANY_ORIGIN=1
# POS_ALLOW_PRIVATE=1
# POS_CONNECT_SRC=https://erp.example.com
# POS_TRUST_PROXY=1
# POS_DISABLE_JSONRPC=1
# POS_HOST=127.0.0.1
# PORT=3000

Development mode (NODE_ENV not production) allows any origin: never use it on a reachable server.

Docker. Copy .env.example to .env and run docker compose up -d. The Dockerfile (Node 24, Next.js standalone output, non-root user, health check) and the compose file are provided; the image was not built and tested here.

# docker-compose.yml
services:
  pos:
    build: .
    restart: unless-stopped
    ports:
      - "3000:3000"
    env_file: .env

# without compose (header of the Dockerfile)
docker build -t taqnix-pos . && docker run -p 3000:3000 --env-file .env taqnix-pos

HTTPS. deploy/nginx.conf.example is a TLS front; run the app with POS_TRUST_PROXY=1 behind it. It sets client_max_body_size 26m (the proxy accepts 25 MB), a 70 second read timeout (the proxy waits 60 seconds for Odoo) and never lets /sw.js be cached, or updates would never arrive. On the internet add a VPN, single sign-on or an IP allow-list (chapter 25).

# TLS front for the terminal (a PWA can only be installed from https:// or http://localhost).
# Run the app with POS_TRUST_PROXY=1 behind this proxy (it writes the X-Forwarded-* headers below).
# Internet-facing? /api/odoo has no login of its own: restrict who reaches it (VPN, SSO / identity-aware
# proxy, or an IP allow-list like the commented `allow`/`deny` lines below).
server {
  listen 443 ssl http2;
  server_name pos.example.com;
  ssl_certificate     /etc/letsencrypt/live/pos.example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/pos.example.com/privkey.pem;

  client_max_body_size 26m;          # the proxy accepts up to 25 MB (orders with many lines, images)

  # allow 203.0.113.0/24;           # the shop's public address(es)
  # deny all;

  location / {
    proxy_pass http://127.0.0.1:3000;
    proxy_set_header Host $host;
    # overwrite (never append) what the client sent: the app trusts these only with POS_TRUST_PROXY=1
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_set_header X-Forwarded-Host $host;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_read_timeout 70s;          # the proxy gives Odoo 60 s
  }

  # The service worker must never be cached by a CDN or by nginx
  location = /sw.js {
    proxy_pass http://127.0.0.1:3000;
    add_header Cache-Control "no-cache, no-store, must-revalidate" always;
  }
}

On each till. Open the HTTPS address in Chrome or Edge once while online: the browser stores the whole app (a service worker), and from then on the terminal starts without a network. Install it with the install button of the browser. The terminal also offers it in a banner (Install, Dismiss), and Settings → About has an Install app button.

1. Create the user (Settings → Users): Internal User with the access right Point of Sale / User, and nothing more unless you need a right below.
2. Log in as that user, open the preferences, Account Security, press New API Key, name it after the terminal and copy the key at once: Odoo shows it only one time.
3. Check the point of sale: its payment methods (one cash method), cash control if you want the cash counted, and the invoice journal if cashiers will use the Invoice switch.
4. Check the taxes and fiscal positions (below), then connect the terminal (chapter 6).

A plain Point of Sale user cannot do a few things in Odoo 19. The Setup test lists what the user lacks, and the terminal works without these rights.

Restaurant. Floors, tables, the kitchen and bar printers with their product categories, the tip product and the service presets (Dine In, Takeout, Delivery) are set in Odoo (Point of Sale → Configuration). The terminal shows them but does not edit the floor plan.

Test connection changes nothing in Odoo. It checks the server, database, login and the right to use the Point of Sale, counts the points of sale, reads the installed apps and asks what the user may do. Save and continue works only after a good test (it runs the test for you if you did not).

The four notes are information, not errors: they list rights the user lacks (chapter 5).

Each card shows the name, Retail or Restaurant, Cash control, and the state of the session. The button says Open, or Continue when a session is already open; it is disabled while a session is being closed. Change server signs out of this server, and the terminal refuses to switch server while orders are unsent.

With cash control you use Count bills and coins (the values come from Odoo; on the picture 4 × 0.05, 5 × 0.10, 8 × 0.25, 4 × 0.50, 10 × 1.00, 6 × 5.00, 5 × 10.00 and 3 × 20.00 make 154.70) or Enter the amount, add an Opening note and press Open session. Without cash control only the note is asked.

The frame. The rail has Sell, Tables (restaurant only), Orders, Customers, Dashboard, Stock, Sync and Settings. The top bar shows the session chip (a menu with Sync and Close session), the connection chip (Online, Syncing n orders, n sync errors, Offline, Offline · n orders waiting; it opens the Sync screen), the cashier, the keyboard-shortcuts button and, with a lock PIN, Lock the terminal.

The catalogue. The search box (Search by name, reference or barcode) ignores capitals and accents. All, Favourites and the category chips filter the tiles. Options marks a product with attributes, Combo a combo. One tap adds the product; the same product again adds to the quantity of its line, as in Odoo. The … button on a tile (or a long press, or a right click) opens its choices. The grid shows at most 1,200 tiles; then it asks you to search or pick a category.

The terminal numbers orders itself (for example 262-1-000001); Odoo gives its own name to the order when it receives it (Main Shop - 000001). The chip 265.83 is the loyalty balance of the customer, Public the pricelist.

Scanner and keyboard. A scanner that works like a keyboard (it types the code fast and ends with Enter) can be used anywhere on the Sell screen, not only in the search box. The terminal reads codes with Odoo's default barcode rules: product barcodes add the product, EAN-13 codes starting with 23 carry a price, with 21 a weight, codes starting with 22 a discount for the selected line, and 042 selects a customer. Settings → Terminal switches the scanner off and sets the maximum time between characters (35 ms by default) and the shortest barcode (6 characters). Scanners were not verified on real hardware.

When a manager PIN is set, the terminal asks for it before the actions you switched on in Settings → Security: discounts, price changes, refunds, removing a line, cancelling an order (chapter 25).

Tablets. In landscape (1024 × 768) the two panels stay. In portrait (768 × 1024) the order collapses into a bar, Review the order, with the item count, the total and the Pay button; tap the bar to open the order.

Variants. Each attribute is a group: pills, a drop-down, colour swatches, or extras you can tick several of, as Odoo displays them. The extra price is written on the value. Choices that cannot be combined are greyed and struck through, and a missing combination says “This combination is not available.” A custom value such as Other (specify) asks for a text; Odoo accepts it only from a user with Products / Create (chapter 5).

Combos. A combo is made of groups. A group title shows how many items you picked out of the maximum (“1 of 2”), and a badge how many are included in the combo price. A group with one item is chosen for you. Add to order works only when every group is complete. The price of a combo item cannot be changed alone. In a restaurant each item goes to the printer of its own category.

Press Customer on the Sell screen. The search looks at the name, the phone (any format), the email and the barcode; New creates a customer without leaving the order.

The card shows the contact data, the pricelist, the fiscal position and the recent orders on this device. Use for the current order sets the customer on the open order. Edit needs the connection and the Contacts / Creation right; here it is greyed and the card says why.

New customer works offline. The customer is saved on the device with the tag Will sync, can be used in orders at once, and is sent to Odoo before the orders that use it. Odoo 19 lets only users with Contacts / Creation create customers: without it the form shows the red box, Odoo refuses the customer, and the orders waiting for it stay in the Sync screen until the right is granted and you press Retry. When not every customer is on the device, Search in Odoo looks on the server (it needs the connection) and keeps what it finds.

The receipt shows what will print: the company block, receipt and order numbers, the customer, the lines with a tax letter (A, C), the subtotal and the taxes by group with their base (“VAT 15% (A) on 24.79”), the payments and the change, the footer text of the point of sale, a Code-128 barcode of the receipt number, and a QR code “Scan to get your invoice” with the address of Odoo's portal and a code (when Odoo's ticket QR option is on). The right side has a badge (On this device, Waiting to sync, Sending to Odoo…, In Odoo), the switch 58 mm / 80 mm, Print and New order.

Printing. Print uses the print function of the browser and prints only the receipt. Choose the printer once in the dialog, margins None, paper size the width of the roll. Chrome prints without the dialog only when started with --kiosk-printing. Settings → Terminal sets the paper width and Print the receipt automatically. There is no direct ESC/POS printing (chapter 27). Old receipts are reprinted from Orders (chapter 13).

What is on the device. A copy of what the terminal needs, in the browser database (IndexedDB): products, variants and combos, customers, taxes and fiscal positions, pricelists, loyalty programmes, the configuration of the point of sale and your open orders. After the first full download the terminal starts from this copy.

Search by receipt number, customer or amount; sort by newest, oldest, largest or smallest. The detail shows the state badges, lines, totals, payments and the Sync history.

Refund. Choose the lines and quantities (the window shows what was sold and already refunded) or Refund everything, then Continue to the refund. The payment screen opens with negative amounts (Refund to customer); pay it out and validate. The terminal counts the refunds already made on this device, so you cannot refund more than what is left. A refund is an order of its own, sent like any other. A manager PIN is asked first if it protects refunds.

The floor plan. Tables opens it. Floors are tabs (Ground floor, Terrace). Tables sit at the position, shape and size they have in Odoo, scaled to the screen; the plan is never mirrored in Arabic. A table shows its number, its Odoo colour dot and, when busy, total, guests and minutes. White is free, blue Occupied, amber To pay (bill printed, nothing changed since). A red chef-hat badge counts items not yet sent to the kitchen. Merge starts a merge; a wide screen also lists Open tables.

Open a table. Tap it: a free table starts an order with one guest, a busy one opens its order. The Sell screen shows a table chip and the kitchen button Order with the number of changes to send. The chip opens the table sheet: guests (1 to 99), the service (Dine In, Takeout, Delivery; it sets the pricelist and fiscal position), Split bill, Bill, Transfer, Floor plan (or Unmerge) and the kitchen section. Leaving a table sends its changes to Odoo.

The kitchen. Each line shows In the kitchen or Not sent. Order sends only what changed since the last time, as Odoo's own point of sale does. A ticket has the sections NEW, CHANGED (with the new quantity) and CANCELLED, notes and options, and combo items under the combo name. There is one ticket for each kitchen printer of Odoo: a line goes to every printer whose product categories contain one of its categories or their parents. Items no printer takes print on the default station Other items. Tips, discounts and rewards never go to the kitchen. Ticket preview shows the tickets first; Reprint prints the last ones marked DUPLICATE.

Split bill. Choose the lines and quantities for the new bill (combo items move with their combo), or use Equal share to select one share of the number of guests. The window shows the New bill and what Stays on the table. Pay this bill opens its payment; Keep open only creates it. The new bill is a separate order named like 5B, 5C, up to 26 parts. Odoo merges every open order of one table into one, so the new bill has no table link on the server; the link is kept on the device and the bill shows on its table in the plan. An order with payments cannot be split. A line cut in two can move one cent between the bills (tax is rounded line by line, as in Odoo).

Bill and tip. Bill opens the Bill preview. Choose No tip, 5, 10, 15 or 20 % of the bill, or a Custom amount and Apply. The tip is a line with Odoo's tip product (set with the Tips option in Odoo); a new choice replaces it, 0 removes it. Print bill prints it, titled “BILL - not a receipt”, and the table turns To pay; Payment goes to the payment screen. Tips after a card payment (a capture) are not supported.

Transfer and merge. Transfer asks for the destination table (“Moving 5: tap the destination table”, with Cancel). To a free table only the table changes; to a busy table the items join its order (equal lines add up) and the emptied order is cancelled, also offline. Merge on the plan does the same: first the table to move, then the destination. Unmerge puts the items of a merged table back on a new order of that table, which must be free.

Buttons: Session, Today, 7 days, 30 days. Cards: Sales, Orders, Average ticket, Tax, Discounts. The chart is by hour for the session and today, by day for 7 and 30 days. Top products lists the eight products with the highest amount, without tips, discounts and rewards.

Type a name, reference or barcode. The table shows On hand, Reserved, Available and Incoming for each warehouse, the warehouse of this point of sale first with the tag This shop. Available below 5 is shown as low, 0 or less as out of stock. By location opens the locations; a product with variants lists each variant. Offline, the screen shows the last answer for each product you looked up, with its time: “Offline: this is the last answer of Odoo, not the current stock.” The tiles of the Sell screen show no stock.

1. Choose a customer on the order: a layaway needs someone who owes the balance.
2. On the payment screen enter the deposit as a normal payment.
3. In the Layaway box press Keep open with deposit. The terminal shows a deposit receipt, LAYAWAY - DEPOSIT, to hand to the customer.
4. Later open More → Layaways and press Collect payment for the customer. Pay the balance and Validate.

Choose a customer, then tap the points chip next to the customer or use More → Rewards & promo code. The card shows the Balance from Odoo (with its time), This order and After. Apply adds a reward to the order as a line; the trash button removes it. A reward that no longer fits after a change is removed, with a message. A promo code such as SUMMER10 is typed in Promo code and works offline.

Using points needs the connection: the terminal asks Odoo first, and takes off the balance the points spent by orders Odoo has not confirmed yet. After the order reaches Odoo the terminal confirms the points once (the queue shows Loyalty points) and the card is credited or debited then. If the loyalty switch is turned off with an order open, its reward lines are removed.

Open Close session from the session chip, the Sync screen or Settings → Terminal identity. The box Before closing checks:

Count the cash by bills and coins or by total. Expected is the opening cash plus cash payments and cash moves. In Other payment methods enter the card terminal's total when it differs from Odoo; the difference is posted at closing. A Closing note stays on the session for the manager. Session summary lists orders, sales, cash, payment methods and, from the orders made on this device, taxes and the products sold most. If the difference is above the threshold (Cash difference that needs a confirmation, 5 by default) you must type the session name. Then press Close the session and confirm.

Print the report through the browser, then Open a new session or Sign out (unsent orders stay on the device). The terminal does not print Odoo's full Z report (it needs accounting rights): a manager prints it in Point of Sale → Reporting → Sales Details.

About shows the version (1.0.0), the build, the Odoo server, the transport and the apps found (ticked, or a dash when absent), Check for update (chapter 29), Install app when the browser offers it, and the Licences. Wipe local data removes the data downloaded from Odoo and downloads it again. Wipe, keep unsent orders keeps unconfirmed orders and changes, the connection and the settings. Wipe everything also deletes the unsent orders: it asks twice, and the second time you type the number of orders that will be lost.

The variables. The light theme is on :root in src/app/globals.css. The other themes override what they change on :root[data-theme="…"]; the rest comes from light. The tokens are --pos-bg, -surface, -surface-2, -border, -fg, -muted, -primary, -primary-fg, -accent, -success, -warning, -danger, then radius, shadow, font and density. An @theme inline block maps Tailwind's utilities to them (bg-surface, text-fg, bg-primary), so components never name a colour.

Add a theme. A theme lives in five places; the example is the real Ocean theme:

/* 1. src/app/globals.css: one block of variables per theme (the tokens a theme does not set come from :root) */
:root[data-theme="ocean"] {
  --pos-bg: #eaf3f9;
  --pos-surface: #ffffff;
  --pos-surface-2: #dcebf4;
  --pos-border: #c4dbe9;
  --pos-fg: #0e2433;
  --pos-muted: #516c7e;
  --pos-primary: #0a6595;
  --pos-primary-fg: #ffffff;
  --pos-accent: #06687f;
}

/* 2. src/lib/theme/prefs.ts: the list of names */
export const THEMES = ['light', 'dark', 'ocean', 'forest', 'sunset'] as const

/* 3. src/lib/theme/themes.ts: the colours of the small theme chips (a test keeps them equal to the stylesheet) */
ocean: { bg: '#eaf3f9', surface: '#ffffff', primary: '#0a6595', accent: '#06687f' },

/* 4. src/app/layout.tsx: the boot script, so there is no flash of the wrong theme */
var T=['light','dark','ocean','forest','sunset'];

/* 5. src/lib/i18n/en/core.ts and ar/core.ts: the name shown on the chip */
'theme.ocean': 'Ocean',

Then check the contrast: src/lib/theme/contrast-themes.test.ts reads the stylesheet and requires 4.5:1 (WCAG AA) for every text and background pair the components use, in every theme, and checks that the chip colours equal the stylesheet. Add the new name to the list in that test. Setup and Settings build their theme chips from THEMES.

Brand colour. The picker writes --pos-primary and --pos-primary-fg on <html>. src/lib/theme/contrast.ts picks a readable text colour, and adjusts a colour that is too pale or dark for the cards (below 3:1). Preferences live in localStorage (pos.prefs), and a small script in layout.tsx applies theme, direction, colour and density before the first paint.

Right to left. The language sets dir on <html>. The CSS uses logical utilities (ms-*, ps-*, text-start), amounts are always left to right (.amount), codes like 262-1-000001 keep their order inside Arabic text, and the floor plan is never mirrored. Fonts: Inter and IBM Plex Sans Arabic, bundled.

Languages. English and Arabic are built in. Texts are flat dictionaries ('sell.pay': 'Pay'), one file for each area in src/lib/i18n/en/ and ar/, read with t('key', {vars}); plural messages have the forms of the language (English two, Arabic six); GLOSSARY.md fixes the Arabic terms. Tests fail when Arabic lacks a key or placeholder of English, when a key used in the code does not exist, and when visible text in src/components bypasses t().

What it covers. Taxes (percentage, fixed, division, group; price included or excluded; negative rates; reverse charge), fiscal positions, pricelists (fixed, percentage, formula, based on another pricelist, dates, quantity tiers), variant extras, combo price split, cash rounding, the whole-order discount, rounding per line or globally, currencies with 0, 2 and 3 decimals. It is plain TypeScript with no browser, database or network (src/lib/engine/, documented in its README).

Where Odoo's own client and server disagree. The terminal computes what Odoo's point-of-sale client computes and sends, because that is what sync_from_ui stores. In a few cases Odoo's server then stores something slightly different:

Deliberate differences. Pricelist items are also filtered by date at the moment of the sale (Odoo's POS filters only at loading, so a terminal running for days would keep an expired promotion). Line totals are rounded to the currency. The tax ids inside each tax group are sorted.

Licence. account_tax.ts, float.ts, pricing.ts, fiscal.ts, order.ts, combo.ts, attributes.ts and discount.ts are ported from Odoo 19. They carry a header naming their origin, are listed in NOTICE and stay under the LGPL-3.0 (LICENSE-LGPL-3.0.txt). The test tools that run Odoo's own JavaScript read it from a local Odoo installation; no Odoo file is copied into the package.

The whole interface is one route, /; screens switch inside it, so a full reload works offline from one cached HTML file. The server side has /api/odoo (the proxy), /manifest.webmanifest and /sw.js (written into public/ by scripts/make-sw.mjs after next build). The browser calls the proxy, which forwards to the allowed Odoo origins (unless you choose the direct mode).

The local database. One Dexie table for each mirrored Odoo model, named like the model with the dot turned into an underscore, keyed by id (product_template, res_partner, account_tax…), plus meta (connection, session, installed modules, last pull, preferences, caches), orders (by uuid), ops (operations that are not orders), images and log. Zustand stores hold screen state; the open order is written to Dexie shortly after each change.

Data in and out. Settings, taxes, pricelists and so on load with Odoo's own point-of-sale loader pos.session.load_data; the catalogue is paged with product.template.load_product_from_pos; later pulls ask for what changed since the server time of the last pull and check deletions on the server. Orders go out with pos.order.sync_from_ui, one for each call, idempotent by uuid; drafts (tables, layaways) go as drafts. Other operations (new customers, loyalty confirmations, cancelling a table order, closing) are queued in ops and run in order before the orders that depend on them.

The feature registry. registerFeature declares which Odoo apps a feature needs (requires.modules), a condition on the point of sale (requires.config), whether it needs the connection (requires.online), its place in the rail (nav), its screen and the slots it fills (cartSlot, paymentSlot, orderActions, lineBadge, settingsPanel). A feature whose app is missing, or that is switched off, is not mounted and its code is never loaded.

Add a Pro feature (the steps of src/lib/pro/README.md, for an example called giftcards):

1. Logic in src/lib/pro/giftcards/ as pure functions with tests. Network only through getOdooCaller() (null offline); check every answer with zod.
2. Cache what must stay readable offline with readCache / writeCache (meta keys pro.giftcards.*).
3. The screen in src/components/pro/giftcards/ (default export); wrap a slot with lazy() in src/components/pro/slots.tsx.
4. Messages pro.giftcards.* in src/lib/i18n/en/pro.ts and ar/pro.ts (the test fails if Arabic lacks a key).
5. Register the feature in the registration file in src/components/extensions/.
6. Add the id to PRO_FEATURE_IDS (src/lib/pro/features.ts) and the texts pro.feature.giftcards and _desc: the feature gets its switch in Settings → Features, on by default.
7. Never import feature code statically in the registration file: a feature that is off or missing must load nothing.

// the registration file of the Pro features (src/components/extensions/): one call per feature
registerFeature({
  id: 'giftcards',
  title: 'Gift cards',
  tier: 'pro',
  requires: { modules: ['pos_loyalty'] },
  nav: { icon: 'gift', labelKey: 'pro.giftcards.title', order: 65 },   // place in the left rail (stock is 60, sync is 70)
  screen: () => import('@/components/pro/giftcards/giftcards-screen'), // loaded only when the feature is on
  // optional: cartSlot, paymentSlot, orderActions, settingsPanel
})

Tests. npm test runs Vitest (jsdom, an in-memory IndexedDB, a fake Odoo in the test process): 3,336 pass and 66 live tests that need a running Odoo 19 are skipped. npm run typecheck runs strict TypeScript and npm run lint ESLint. To run the live tests on your own Odoo 19 test database set POS_TEST_URL, POS_TEST_DB, POS_TEST_LOGIN, POS_TEST_SECRET (an API key) and POS_TEST_ADMIN_SECRET (an administrator's key) and run npx vitest run tests/live; some also need psql access (PGPASSWORD). They open and close sessions: never run them on a production database.

The key on the device. The browser keeps the Odoo key in IndexedDB. Without a lock PIN it is stored as it is. With a lock PIN it is encrypted (the PIN goes through PBKDF2-SHA-256 to an AES-GCM key) and the decrypted copy lives only in memory. The PIN is asked at start and after an automatic lock.

The proxy. Every call of the browser goes to /api/odoo, built as a narrow door:

Headers. Every page carries a Content-Security-Policy (default-src 'self': everything from the app itself plus POS_CONNECT_SRC; inline scripts and styles stay allowed because the framework needs them), nosniff, Referrer-Policy: same-origin, X-Frame-Options: SAMEORIGIN and a Permissions-Policy that gives camera, USB, serial and Bluetooth to the app only.

Totals follow Odoo's point of sale. The terminal matched Odoo 19's own Python tax helpers on 667 of 667 reference scenarios, Odoo's own JavaScript on 664 of 667 (3 documented exceptions), and, in an independent replay of 1,149 orders sent to Odoo 19 as a cashier, Odoo's Python on every order (chapter 23 has the details). Where Odoo's own client and server disagree, the terminal does what Odoo's client does. It does not compute Python-code taxes or pricelists in another currency.

Offline guarantees. A paid order is written to the device before the receipt shows. It is sent once: Odoo matches it by its unique id, so a lost answer cannot create a second order. A synced order is removed from the device only after Odoo confirmed it and after the retention period (14 days by default); an order Odoo has not confirmed is never removed by the terminal. This assumes the browser keeps its data: if the browser data is cleared, unsent orders are lost (chapter 12).

Performance, and where it was measured. All numbers come from one Apple Silicon Mac with Odoo, the app and the browser on the same computer and a window of 1366 × 768 (not a tablet). On a tablet and a real network the times will be longer.

The tests. npm test passes 3,336 tests; 66 more, which need a running Odoo 19, are skipped by default.

1. Put the new files in place of the old ones and keep your .env.
2. Ready-to-run app: unzip the new taqnix-pos-terminal-webapp.zip into a new folder, copy your .env into it, stop the old terminal and start the new one. From the source: run npm ci and npm run build, then restart the app (or rebuild the Docker image and start it again).
3. Each build has its own build id inside the service worker. Open terminals look for a new version every 10 minutes and when you press Check for update in Settings → About.
4. The new version downloads in the background and a banner appears: A new version of the terminal is ready. with Later and Update.
5. When the cashier presses Update, the terminal saves the open order, reloads into the new version, and the order is back.

Orders not yet sent, the connection, the lock PIN and the settings stay in the browser through an update. Updates of the 1.x versions are included in the price.

Backup. The master data is in Odoo: back it up as usual. A till holds only a copy and the orders Odoo has not received. On the server, keep your .env and any change you made to the source. To set up a till like another one, Export settings on the old one and Import settings on the new one; the file has no connection, so run Setup on the new till.

Write with your Odoo version, the browser and its version, the device and screen size, a screenshot or a short description of what you did, and the file from Sync → Export diagnostics. That file has no passwords, keys or PINs, no customer data and no order lines.

The full text is licensing/license.txt. Odoo is a trademark of Odoo S.A.; this product is not made or endorsed by Odoo S.A.