437 lines
19 KiB
JavaScript
437 lines
19 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { mkdtempSync, rmSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
import LibDashStore from '../src/index.js';
|
|
import { BetterSqlite3Provider } from '../src/providers/sqlite3/index.js';
|
|
|
|
async function run() {
|
|
console.log('--- Testing posterminalsyncqueue table and sync queue flow ---');
|
|
|
|
const tempDir = mkdtempSync(join(tmpdir(), 'test-syncqueue-'));
|
|
const dbFile = join(tempDir, 'test.db');
|
|
const storageDir = join(tempDir, 'storage');
|
|
|
|
const provider = new BetterSqlite3Provider({
|
|
filename: dbFile,
|
|
storageDir,
|
|
});
|
|
|
|
await provider.initialize();
|
|
const store = await new LibDashStore(provider);
|
|
|
|
const clearQueue = () => {
|
|
provider.db.prepare('DELETE FROM posterminalsyncqueue').run();
|
|
};
|
|
|
|
const getQueue = () =>
|
|
provider.db
|
|
.prepare('SELECT posterminal_id, entity_type, entity_id FROM posterminalsyncqueue ORDER BY id ASC')
|
|
.all();
|
|
|
|
try {
|
|
// 1. Verify posterminalsyncqueue table exists and has expected columns
|
|
console.log('1. Checking posterminalsyncqueue schema...');
|
|
const tableInfo = provider.db.pragma('table_info("posterminalsyncqueue")');
|
|
const colNames = tableInfo.map((c) => c.name);
|
|
console.log('posterminalsyncqueue columns:', colNames);
|
|
assert.deepEqual(colNames, [
|
|
'id',
|
|
'posterminal_id',
|
|
'entity_type',
|
|
'entity_id',
|
|
]);
|
|
|
|
// 2. Setup company & 2 POS terminals + another company with 1 terminal (to test company scoping)
|
|
console.log('2. Setting up base data with 2 terminals in company 1 and 1 terminal in company 2...');
|
|
const googleAuthId = await store.google_auth.add('syncqueue-tester@example.com');
|
|
const company1 = await store.company.create({
|
|
name: 'SyncQueue Corp 1',
|
|
iso639: 'de',
|
|
taxrate: 19,
|
|
reducedtaxrate: 7,
|
|
googleAuthId,
|
|
});
|
|
const company2 = await store.company.create({
|
|
name: 'SyncQueue Corp 2',
|
|
iso639: 'de',
|
|
taxrate: 19,
|
|
reducedtaxrate: 7,
|
|
googleAuthId,
|
|
});
|
|
|
|
await store.google_auth.setSelectedCompany(googleAuthId, company2.id);
|
|
const otherTerminal = await store.posterminal.upsert(googleAuthId, {
|
|
name: 'Other Corp Terminal',
|
|
pairingpin: '9999',
|
|
});
|
|
|
|
await store.google_auth.setSelectedCompany(googleAuthId, company1.id);
|
|
const term1 = await store.posterminal.upsert(googleAuthId, {
|
|
name: 'POS Terminal 1',
|
|
pairingpin: '1111',
|
|
});
|
|
const term2 = await store.posterminal.upsert(googleAuthId, {
|
|
name: 'POS Terminal 2',
|
|
pairingpin: '2222',
|
|
});
|
|
|
|
// Helper to assert that both term1 and term2 received the expected entity_type + entity_id, and otherTerminal did not
|
|
const assertQueuedForBothTerminals = (entityType, entityId, label) => {
|
|
const rows = getQueue();
|
|
const matching = rows.filter((r) => r.entity_type === entityType && r.entity_id === entityId);
|
|
const termIds = matching.map((r) => r.posterminal_id).sort((a, b) => a - b);
|
|
assert.deepEqual(
|
|
termIds,
|
|
[term1.id, term2.id],
|
|
`Expected [${term1.id}, ${term2.id}] for ${label} (${entityType}:${entityId}), got ${JSON.stringify(rows)}`,
|
|
);
|
|
const otherRows = rows.filter((r) => r.posterminal_id === otherTerminal.id);
|
|
assert.equal(otherRows.length, 0, `Other company terminal should not receive rows (${label})`);
|
|
};
|
|
|
|
// 3. Test Category operations
|
|
console.log('3. Testing category operations...');
|
|
clearQueue();
|
|
const catA = await store.category.createUnderParent({
|
|
googleAuthId,
|
|
parentId: company1.rootCategoryId,
|
|
name: 'Category A',
|
|
});
|
|
assertQueuedForBothTerminals('category', catA.id, 'category.createUnderParent');
|
|
|
|
clearQueue();
|
|
await store.category.rename({
|
|
googleAuthId,
|
|
id: catA.id,
|
|
name: 'Category A Renamed',
|
|
});
|
|
assertQueuedForBothTerminals('category', catA.id, 'category.rename');
|
|
|
|
clearQueue();
|
|
const catLeafId = await store.category.ensureByPath({
|
|
googleAuthId,
|
|
parentId: company1.rootCategoryId,
|
|
path: 'Category B | Subcategory B1',
|
|
});
|
|
assertQueuedForBothTerminals('category', catLeafId, 'category.ensureByPath');
|
|
|
|
const catBRow = provider.db
|
|
.prepare('SELECT c.id FROM category c WHERE c.parent_id = ? AND c.id != ?')
|
|
.get(company1.rootCategoryId, catA.id);
|
|
clearQueue();
|
|
await store.category.order({
|
|
googleAuthId,
|
|
parentId: company1.rootCategoryId,
|
|
categoryIds: [catBRow.id, catA.id],
|
|
});
|
|
assertQueuedForBothTerminals('category', catA.id, 'category.order');
|
|
assertQueuedForBothTerminals('category', catBRow.id, 'category.order (sibling)');
|
|
|
|
clearQueue();
|
|
await store.category.move({
|
|
googleAuthId,
|
|
id: catLeafId,
|
|
parentId: catA.id,
|
|
});
|
|
assertQueuedForBothTerminals('category', catLeafId, 'category.move');
|
|
|
|
const prop = await store.propertyname.create(googleAuthId, { name: 'Color', exclusive: false });
|
|
clearQueue();
|
|
await store.categoryproperty.setByCategoryId(googleAuthId, catA.id, [
|
|
{ propertyId: prop.id, value: 'Red' },
|
|
]);
|
|
assertQueuedForBothTerminals('category', catA.id, 'categoryproperty.setByCategoryId');
|
|
|
|
clearQueue();
|
|
await store.categoryproperty.delete(googleAuthId, catA.id, prop.id);
|
|
assertQueuedForBothTerminals('category', catA.id, 'categoryproperty.delete');
|
|
|
|
const attr = await store.attributename.create(googleAuthId, { name: 'Size', exclusive: true });
|
|
const attrVal = await store.attributevalue.create(googleAuthId, attr.id, { value: 'XL' });
|
|
clearQueue();
|
|
await store.categoryattributevalue.setByCategoryId(googleAuthId, catA.id, [attrVal.id]);
|
|
assertQueuedForBothTerminals('category', catA.id, 'categoryattributevalue.setByCategoryId');
|
|
|
|
// 4. Test Article operations
|
|
console.log('4. Testing article operations...');
|
|
clearQueue();
|
|
const art1 = await store.article.createUnderParent({
|
|
googleAuthId,
|
|
parentId: catA.id,
|
|
name: 'Cola 0.33L',
|
|
});
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.createUnderParent');
|
|
|
|
clearQueue();
|
|
await store.article.updateBySku(googleAuthId, art1.sku, { name: 'Cola Classic 0.33L' });
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.updateBySku');
|
|
|
|
clearQueue();
|
|
await store.article.setPricesBySku(googleAuthId, art1.sku, [{ net: 1.5, taxRate: 19 }]);
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.setPricesBySku');
|
|
|
|
clearQueue();
|
|
await store.article.setEansBySku(googleAuthId, art1.sku, ['4001234567890']);
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.setEansBySku');
|
|
|
|
const brand = await store.brand.create(googleAuthId, { name: 'ColaBrand' });
|
|
clearQueue();
|
|
await store.article.setBrandIdBySku(googleAuthId, art1.sku, brand.id);
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.setBrandIdBySku');
|
|
|
|
clearQueue();
|
|
await store.brand.update(googleAuthId, brand.id, { name: 'ColaBrand Updated' });
|
|
assertQueuedForBothTerminals('article', art1.id, 'brand.update');
|
|
|
|
clearQueue();
|
|
await store.article.setWeightBySku(googleAuthId, art1.sku, 0.35);
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.setWeightBySku');
|
|
|
|
const wh = await store.warehouse.create(googleAuthId, { name: 'Main Warehouse' });
|
|
clearQueue();
|
|
await store.article.setTrackStockBySku(googleAuthId, art1.sku, true);
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.setTrackStockBySku');
|
|
|
|
clearQueue();
|
|
await store.stock.adjust(googleAuthId, {
|
|
sku: art1.sku,
|
|
warehouseId: wh.id,
|
|
amount: 10,
|
|
text: 'Initial stock',
|
|
});
|
|
assertQueuedForBothTerminals('article', art1.id, 'stock.adjust');
|
|
|
|
clearQueue();
|
|
await store.article.setCategoryIdsBySku(googleAuthId, art1.sku, [catA.id, catLeafId]);
|
|
assertQueuedForBothTerminals('article', art1.id, 'article.setCategoryIdsBySku');
|
|
|
|
clearQueue();
|
|
await store.articleproperty.setByArticleSku(googleAuthId, art1.sku, [
|
|
{ propertyId: prop.id, value: 'Dark' },
|
|
]);
|
|
assertQueuedForBothTerminals('article', art1.id, 'articleproperty.setByArticleSku');
|
|
|
|
clearQueue();
|
|
await store.articleproperty.delete(googleAuthId, art1.sku, prop.id);
|
|
assertQueuedForBothTerminals('article', art1.id, 'articleproperty.delete');
|
|
|
|
clearQueue();
|
|
await store.articleattributevalue.setByArticleSku(googleAuthId, art1.sku, [attrVal.id]);
|
|
assertQueuedForBothTerminals('article', art1.id, 'articleattributevalue.setByArticleSku');
|
|
|
|
clearQueue();
|
|
await store.attributevalue.update(googleAuthId, attrVal.id, { value: 'XXL' });
|
|
assertQueuedForBothTerminals('article', art1.id, 'attributevalue.update');
|
|
|
|
// Optionslist & Stückliste
|
|
const pfand = await store.article.createUnderParent({
|
|
googleAuthId,
|
|
parentId: catA.id,
|
|
name: 'Pfand 0.25',
|
|
});
|
|
clearQueue();
|
|
await store.optionslist.setOptionsByArticleSku(googleAuthId, art1.sku, [
|
|
{ sku: pfand.sku, count: 1, mandated: true },
|
|
]);
|
|
assertQueuedForBothTerminals('article', art1.sku ? art1.id : 0, 'optionslist.setOptionsByArticleSku');
|
|
|
|
// Updating option article price should also enqueue parent article!
|
|
clearQueue();
|
|
await store.article.setPricesBySku(googleAuthId, pfand.sku, [{ net: 0.25, taxRate: 19 }]);
|
|
assertQueuedForBothTerminals('article', pfand.id, 'setPricesBySku (option itself)');
|
|
assertQueuedForBothTerminals('article', art1.id, 'setPricesBySku (option parent)');
|
|
|
|
const bundle = await store.article.createUnderParent({
|
|
googleAuthId,
|
|
parentId: catA.id,
|
|
name: 'Cola Crate',
|
|
});
|
|
clearQueue();
|
|
await store.articlelist.setItemsByArticleSku(googleAuthId, bundle.sku, [
|
|
{ sku: art1.sku, count: 6 },
|
|
]);
|
|
assertQueuedForBothTerminals('article', bundle.id, 'articlelist.setItemsByArticleSku');
|
|
|
|
// Adjusting component stock should also enqueue Stückliste parent!
|
|
clearQueue();
|
|
await store.stock.adjust(googleAuthId, {
|
|
sku: art1.sku,
|
|
warehouseId: wh.id,
|
|
amount: 2,
|
|
text: 'Restock component',
|
|
});
|
|
assertQueuedForBothTerminals('article', art1.id, 'stock.adjust (component)');
|
|
assertQueuedForBothTerminals('article', bundle.id, 'stock.adjust (Stückliste parent)');
|
|
|
|
// 5. Test Customer Group operations
|
|
console.log('5. Testing customergroup operations...');
|
|
clearQueue();
|
|
const cg1 = await store.customergroup.create(googleAuthId, { name: 'B2B' });
|
|
assertQueuedForBothTerminals('customergroup', cg1.id, 'customergroup.create');
|
|
|
|
clearQueue();
|
|
await store.customergroup.update(googleAuthId, cg1.id, { name: 'B2B Gold' });
|
|
assertQueuedForBothTerminals('customergroup', cg1.id, 'customergroup.update');
|
|
|
|
const allGroups = await store.customergroup.list(googleAuthId);
|
|
clearQueue();
|
|
await store.customergroup.order(googleAuthId, {
|
|
customergroupIds: allGroups.map((g) => g.id).reverse(),
|
|
});
|
|
assertQueuedForBothTerminals('customergroup', cg1.id, 'customergroup.order');
|
|
|
|
// 6. Test Customer (Entity + Address + Contact) operations
|
|
console.log('6. Testing customer (entity, entityaddress, entitycontact) operations...');
|
|
clearQueue();
|
|
const cust = await store.entity.create(googleAuthId, {
|
|
customergroupId: cg1.id,
|
|
name: 'Doe',
|
|
firstName: 'John',
|
|
});
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entity.create');
|
|
|
|
clearQueue();
|
|
await store.entity.update(googleAuthId, cust.id, { firstName: 'Johnny' });
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entity.update');
|
|
|
|
clearQueue();
|
|
const addr = await store.entityaddress.create(googleAuthId, cust.id, {
|
|
addressType: 'billing',
|
|
street: 'Main St 1',
|
|
city: 'Berlin',
|
|
});
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entityaddress.create');
|
|
|
|
clearQueue();
|
|
await store.entityaddress.update(googleAuthId, cust.id, addr.id, {
|
|
city: 'Munich',
|
|
});
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entityaddress.update');
|
|
|
|
clearQueue();
|
|
await store.entityaddress.delete(googleAuthId, cust.id, addr.id);
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entityaddress.delete');
|
|
|
|
clearQueue();
|
|
const contact = await store.entitycontact.create(googleAuthId, cust.id, {
|
|
contactType: 'email',
|
|
contact: 'john@example.com',
|
|
});
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entitycontact.create');
|
|
|
|
clearQueue();
|
|
await store.entitycontact.update(googleAuthId, cust.id, contact.id, {
|
|
contact: 'johnny@example.com',
|
|
});
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entitycontact.update');
|
|
|
|
clearQueue();
|
|
await store.entitycontact.delete(googleAuthId, cust.id, contact.id);
|
|
assertQueuedForBothTerminals('customer', cust.id, 'entitycontact.delete');
|
|
|
|
// 7. Test CHECK constraint on entity_type
|
|
console.log('7. Testing entity_type CHECK constraint...');
|
|
assert.throws(() => {
|
|
provider.db
|
|
.prepare('INSERT INTO posterminalsyncqueue (posterminal_id, entity_type, entity_id) VALUES (?, ?, ?)')
|
|
.run(term1.id, 'invalid_type', 1);
|
|
}, /CHECK constraint failed/);
|
|
|
|
// 8. Test POS Sync Cursor (posterminalsyncqueue.id) across counts and lists
|
|
console.log('8. Testing POS Sync Cursor (posterminalsyncqueue.id) for counts & lists...');
|
|
// Create a fresh terminal (term3) and enable all categories on it to verify full initial sync + delta cursor
|
|
const term3 = await store.posterminal.upsert(googleAuthId, {
|
|
name: 'POS Terminal 3',
|
|
pairingpin: '3333',
|
|
});
|
|
await store.posterminal.setOnAll(googleAuthId, term3.id);
|
|
|
|
// Initial sync with cursor = 0
|
|
const initProductCount = await store.posterminal.getProductCount({ posterminalId: term3.id, cursor: 0 });
|
|
const initCategoryCount = await store.posterminal.getCategoryCount({ posterminalId: term3.id, cursor: 0 });
|
|
const initCustomerCount = await store.posterminal.getCustomerCount({ posterminalId: term3.id, cursor: 0 });
|
|
const initCustomerGroupCount = await store.posterminal.getCustomerGroupCount({ posterminalId: term3.id, cursor: 0 });
|
|
const initCompositeCount = await store.posterminal.getCompositeProductCount({ posterminalId: term3.id, cursor: 0 });
|
|
|
|
assert.ok(initProductCount > 0, `Expected initProductCount > 0, got ${initProductCount}`);
|
|
assert.ok(initCategoryCount > 0, `Expected initCategoryCount > 0, got ${initCategoryCount}`);
|
|
assert.ok(initCustomerCount > 0, `Expected initCustomerCount > 0, got ${initCustomerCount}`);
|
|
assert.ok(initCustomerGroupCount > 0, `Expected initCustomerGroupCount > 0, got ${initCustomerGroupCount}`);
|
|
assert.ok(initCompositeCount > 0, `Expected initCompositeCount > 0, got ${initCompositeCount}`);
|
|
|
|
const products = await store.posterminal.getProductList({ posterminalId: term3.id, cursor: 0, limit: 100 });
|
|
const categories = await store.posterminal.getCategoryList({ posterminalId: term3.id, cursor: 0, limit: 100 });
|
|
const customers = await store.posterminal.getCustomerList({ posterminalId: term3.id, cursor: 0, limit: 100 });
|
|
const customerGroups = await store.posterminal.getCustomerGroupList({ posterminalId: term3.id, cursor: 0, limit: 100 });
|
|
|
|
assert.equal(products.length, initProductCount);
|
|
assert.equal(categories.length, initCategoryCount);
|
|
assert.equal(customers.length, initCustomerCount);
|
|
assert.equal(customerGroups.length, initCustomerGroupCount);
|
|
|
|
// Advance cursors to max lastChanged
|
|
const maxProductCursor = Math.max(...products.map((p) => Number(p.lastChanged)));
|
|
const maxCategoryCursor = Math.max(...categories.map((c) => Number(c.lastChanged)));
|
|
const maxCustomerCursor = Math.max(...customers.map((c) => Number(c.lastChanged)));
|
|
const maxCustomerGroupCursor = Math.max(...customerGroups.map((cg) => Number(cg.lastChanged)));
|
|
|
|
// Verify all counts and lists are 0 at the current cursors
|
|
assert.equal(await store.posterminal.getProductCount({ posterminalId: term3.id, cursor: maxProductCursor }), 0);
|
|
assert.equal(await store.posterminal.getCategoryCount({ posterminalId: term3.id, cursor: maxCategoryCursor }), 0);
|
|
assert.equal(await store.posterminal.getCustomerCount({ posterminalId: term3.id, cursor: maxCustomerCursor }), 0);
|
|
assert.equal(await store.posterminal.getCustomerGroupCount({ posterminalId: term3.id, cursor: maxCustomerGroupCursor }), 0);
|
|
assert.equal(await store.posterminal.getCompositeProductCount({ posterminalId: term3.id, cursor: maxProductCursor }), 0);
|
|
|
|
assert.equal((await store.posterminal.getProductList({ posterminalId: term3.id, cursor: maxProductCursor })).length, 0);
|
|
assert.equal((await store.posterminal.getCategoryList({ posterminalId: term3.id, cursor: maxCategoryCursor })).length, 0);
|
|
assert.equal((await store.posterminal.getCustomerList({ posterminalId: term3.id, cursor: maxCustomerCursor })).length, 0);
|
|
assert.equal((await store.posterminal.getCustomerGroupList({ posterminalId: term3.id, cursor: maxCustomerGroupCursor })).length, 0);
|
|
|
|
// Now touch one article twice, one category, one customer, one customergroup
|
|
await store.article.updateBySku(googleAuthId, art1.sku, { name: 'Cola Classic v2' });
|
|
await store.article.updateBySku(googleAuthId, art1.sku, { name: 'Cola Classic v3' });
|
|
await store.category.rename({ googleAuthId, id: catA.id, name: 'Category A v2' });
|
|
await store.entity.update(googleAuthId, cust.id, { firstName: 'John v2' });
|
|
await store.customergroup.update(googleAuthId, cg1.id, { name: 'B2B Platinum' });
|
|
|
|
// Even though art1 was updated twice, count should be 1 (deduplicated by entity_id with MAX(id) > cursor)
|
|
assert.equal(await store.posterminal.getProductCount({ posterminalId: term3.id, cursor: maxProductCursor }), 1);
|
|
assert.equal(await store.posterminal.getCategoryCount({ posterminalId: term3.id, cursor: maxCategoryCursor }), 1);
|
|
assert.equal(await store.posterminal.getCustomerCount({ posterminalId: term3.id, cursor: maxCustomerCursor }), 1);
|
|
assert.equal(await store.posterminal.getCustomerGroupCount({ posterminalId: term3.id, cursor: maxCustomerGroupCursor }), 1);
|
|
|
|
const deltaProducts = await store.posterminal.getProductList({ posterminalId: term3.id, cursor: maxProductCursor });
|
|
const deltaCategories = await store.posterminal.getCategoryList({ posterminalId: term3.id, cursor: maxCategoryCursor });
|
|
const deltaCustomers = await store.posterminal.getCustomerList({ posterminalId: term3.id, cursor: maxCustomerCursor });
|
|
const deltaCustomerGroups = await store.posterminal.getCustomerGroupList({ posterminalId: term3.id, cursor: maxCustomerGroupCursor });
|
|
|
|
assert.equal(deltaProducts.length, 1);
|
|
assert.equal(deltaProducts[0]._id, String(art1.id));
|
|
assert.ok(Number(deltaProducts[0].lastChanged) > maxProductCursor);
|
|
|
|
assert.equal(deltaCategories.length, 1);
|
|
assert.equal(deltaCategories[0]._id, String(catA.id));
|
|
assert.ok(Number(deltaCategories[0].lastChanged) > maxCategoryCursor);
|
|
|
|
assert.equal(deltaCustomers.length, 1);
|
|
assert.equal(deltaCustomers[0].id, String(cust.id));
|
|
assert.ok(Number(deltaCustomers[0].lastChanged) > maxCustomerCursor);
|
|
|
|
assert.equal(deltaCustomerGroups.length, 1);
|
|
assert.equal(deltaCustomerGroups[0].customerGroupId, String(cg1.id));
|
|
assert.ok(Number(deltaCustomerGroups[0].lastChanged) > maxCustomerGroupCursor);
|
|
|
|
console.log('✅ ALL POSTERMINALSYNCQUEUE TESTS PASSED');
|
|
} finally {
|
|
try {
|
|
rmSync(tempDir, { recursive: true, force: true });
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
run().catch((err) => {
|
|
console.error('Test failed:', err);
|
|
process.exit(1);
|
|
});
|