@dooer/dooer-test-env 1.4.0 → 1.5.0

package/lib/account.js

@@ -15,9 +15,12 @@
 
 const crypto = require('crypto')
 const { Client } = require('pg')
+const { apiRequest, serviceToken } = require('./api')
 
-// Ghost Inspector's active subscription set on staging (Jimmy 2026-09-01).
-const SUBSCRIPTION_TYPES = ['accounting', 'billing', 'salaries', 'sales', 'prebook']
+// Ghost Inspector's active subscription set on staging (Jimmy 2026-09-01). ORDER MATTERS: service-accounts
+// rejects `billing` unless a `sales` subscription already exists (prerequisite-subscription-not-found), so
+// sales is created first — a rule the old direct-INSERT path silently bypassed.
+const SUBSCRIPTION_TYPES = ['accounting', 'sales', 'billing', 'salaries', 'prebook']
 
 // The partner every new test account is placed under by default (Jimmy 2026-09-01).
 const DEFAULT_PARTNER_DOMAIN = 'dooer'
@@ -85,7 +88,7 @@ async function createAccount({ local, name, ownerUserId, execute = false, fiscal
     ])
     if (!partner.rowCount) throw new Error(`partner '${DEFAULT_PARTNER_DOMAIN}' not found in the local DB`)
 
-    const orgId = uuid()
+    let orgId = uuid()
     const shortName = await uniqueSlug(client, name)
     const plan = {
       orgId,
@@ -104,51 +107,75 @@ async function createAccount({ local, name, ownerUserId, execute = false, fiscal
       return plan
     }
 
-    await client.query('BEGIN')
-    await client.query(
-      // Populate a placeholder address: some org endpoints serialize organization.address as a required
-      // OBJECT and return null (schema violation, seen in sumify) when all address columns are empty.
-      // The registration/fiscal-year columns are NULL unless the defaults are enabled (--no-fiscal-year).
-      `INSERT INTO service_accounts.companies
-         (companies_pk, fk_countries_pk, fk_company_types_pk, company_name, short_name, organization_number,
-          api_uuid, language, "timeZone", currency, address, postal_code, city,
-          bookkeeping_start_date, skv_fiscal_year_start, skv_fiscal_year_end,
-          is_registered_for_vat, vat_registration_date, registered_for_f_tax, is_employer,
-          inserted_at, updated_at)
-       VALUES ($1,'SE','AB',$2,$3,$4,$5,'sv','Europe/Stockholm','SEK','Testgatan 1','11111','Stockholm',
-               $6,$7,$8,$9,$10,$11,$12,now(),now())`,
-      [
-        orgId,
+    // ── Provision through the product APIs, NOT direct SQL ──────────────────────────────────────────
+    // API writes publish domain events; service-closing generates accounting periods from
+    // `company-created` and `fiscal-year-created`, and VAT periods follow the same way. A direct INSERT
+    // yields rows with none of that ("no period exists"). (Jimmy 2026-09-03.)
+    const token = serviceToken()
+    const acct = (method, path, body, label) =>
+      apiRequest({ service: 'service-accounts', method, path, body, token, label })
+
+    // 1. the organization + owner (fires company-created → period generator)
+    const created = acct(
+      'POST',
+      '/v1/organizations',
+      {
         name,
         shortName,
-        orgNumber(),
-        uuid(),
-        fiscalYear ? fy.start : null, // bookkeeping_start_date
-        fiscalYear ? fy.start : null, // skv_fiscal_year_start
-        fiscalYear ? fy.end : null, // skv_fiscal_year_end
-        fiscalYear ? true : null, // is_registered_for_vat
-        fiscalYear ? fy.start : null, // vat_registration_date
-        fiscalYear ? true : null, // registered_for_f_tax
-        fiscalYear ? true : null, // is_employer
-      ]
-    )
-    await client.query(
-      `INSERT INTO service_accounts.companies2users
-         (fk_companies_pk, fk_users_pk, fk_user_roles_at_companies_pk, api_uuid)
-       VALUES ($1,$2,'Owner',$3)`,
-      [orgId, ownerUserId, uuid()]
+        organizationNumber: orgNumber(),
+        vatNumber: null,
+        countryCode: 'SE',
+        companyType: 'AB',
+        address: { addressLines: ['Testgatan 1'], postalCode: '11111', city: 'Stockholm', country: 'SE' },
+        bookkeepingStartDate: fiscalYear ? fy.start : null,
+        bookkeepingEndDate: null,
+        bookkeepingMethod: 'invoiceBased',
+        businessDescription: null,
+        isEmployer: !!fiscalYear,
+        isInactivated: false,
+        ownerUserId,
+        language: 'sv',
+        timeZone: 'Europe/Stockholm',
+        sniCodes: [],
+        tags: [],
+      },
+      'create organization'
     )
+    orgId = (created.json && created.json.id) || orgId
+    plan.orgId = orgId
+
+    // 2. subscriptions
     for (const type of SUBSCRIPTION_TYPES) {
-      await client.query(
-        `INSERT INTO service_accounts.subscriptions
-           (subscriptions_pk, fk_companies_pk, subscription_type, status, start_date, api_uuid, inserted_at, updated_at)
-         VALUES ($1,$2,$3,'active',now(),$4,now(),now())`,
-        [uuid(), orgId, type, uuid()]
+      acct(
+        'POST',
+        `/v1/organizations/${orgId}/subscriptions`,
+        { subscriptionType: type, status: 'active', startDate: fy.start },
+        `subscription ${type}`
+      )
+    }
+
+    // 3. registration fields that only PATCH accepts (VAT / F-skatt / SKV fiscal year)
+    if (fiscalYear) {
+      acct(
+        'PATCH',
+        `/v1/organizations/${orgId}`,
+        {
+          isVatRegistered: true,
+          vatRegistrationDate: fy.start,
+          isFSkattRegistered: true,
+          isEmployer: true,
+          bookkeepingStartDate: fy.start,
+          skvFiscalYear: { startDate: fy.start, endDate: fy.end },
+        },
+        'organization information'
       )
     }
+
+    // 4. the partner link — no dedicated API route, and nothing derives from it
     await client.query(
       `INSERT INTO service_accounts."partnerOrganization" (id, "partnerId", "organizationId", "createdAt", "updatedAt")
-       VALUES ($1,$2,$3,now(),now())`,
+       VALUES ($1,$2,$3,now(),now())
+       ON CONFLICT DO NOTHING`,
       [uuid(), partner.rows[0].id, orgId]
     )
     // Pre-accept the current Terms of Service so the account is ready to use (sumify otherwise prompts and
@@ -166,15 +193,20 @@ async function createAccount({ local, name, ownerUserId, execute = false, fiscal
     plan.tosAccepted = activeTos.rowCount
 
     if (fiscalYear) {
-      // The fiscal year itself (service-ledger owns it; HQ's "Räkenskapsår" + all booking depends on it).
-      await client.query(
-        `INSERT INTO service_ledger.fiscal_year (id, company_id, start_date, end_date, created_at, closed)
-         VALUES ($1,$2,$3,$4,now(),false)`,
-        [uuid(), orgId, fy.start, fy.end]
-      )
-      // The temporal source of truth mirroring the columns set above. `fiscalYear` carries the period in
-      // both the value and the row's own start/endDate (matching how ibSync writes it); the registration
-      // flags are open-ended from the start of the year.
+      // 6. the fiscal year, through service-ledger (fires fiscal-year-created → service-closing generates
+      // the accounting periods; a direct INSERT is what produced "no period exists").
+      apiRequest({
+        service: 'service-ledger',
+        method: 'POST',
+        path: `/v1/organizations/${orgId}/fiscal-years`,
+        body: { startDate: fy.start, endDate: fy.end, chartOfAccountsName: 'dooer-ab' },
+        token,
+        label: 'create fiscal year',
+      })
+
+      // 7. the temporal key/values the platform reads. `fiscalYear` carries the period in both the value
+      // and the row's own start/endDate (matching how ibSync writes it); the registration flags are
+      // open-ended from the start of the year.
       const tkv = [
         { key: 'fiscalYear', value: { start: fy.start, end: fy.end }, startDate: fy.start, endDate: fy.end },
         { key: 'hasVatRegistration', value: true, startDate: fy.start, endDate: null },
@@ -182,25 +214,12 @@ async function createAccount({ local, name, ownerUserId, execute = false, fiscal
         { key: 'hasEmployeeRegistration', value: true, startDate: fy.start, endDate: null },
       ]
       for (const t of tkv) {
-        await client.query(
-          `INSERT INTO service_accounts."temporalKeyValue"
-             (id, "organizationId", key, value, "startDate", "endDate", "setBySource", "createdAt", "updatedAt")
-           VALUES ($1,$2,$3,$4::jsonb,$5,$6,'user',now(),now())`,
-          [uuid(), orgId, t.key, JSON.stringify(t.value), t.startDate, t.endDate]
-        )
+        acct('POST', `/v1/organizations/${orgId}/temporal-key-values`, t, `temporal key ${t.key}`)
       }
       plan.temporalKeys = tkv.map((t) => t.key)
     }
 
-    await client.query('COMMIT')
     return plan
-  } catch (e) {
-    try {
-      await client.query('ROLLBACK')
-    } catch (_) {
-      /* ignore */
-    }
-    throw e
   } finally {
     await client.end()
   }

package/lib/api.js

@@ -0,0 +1,103 @@
+// Call a running service's own HTTP API from the host.
+//
+// Backend services are NOT published to the host (only public-facade/service-graphql are), and the facade
+// only proxies a whitelisted route set — so we talk to a service the same way its peers do: from INSIDE the
+// compose network, by exec'ing into that service's container and calling its localhost:3000.
+//
+// Why the API and not direct SQL: writes through the API publish domain events. service-closing generates
+// accounting periods from `company-created` and `fiscal-year-created`; VAT periods and other derived state
+// come the same way. A direct INSERT produces a row with none of that, so the account looks provisioned but
+// has "no period exists" everywhere. (Jimmy 2026-09-03.)
+
+const { spawnSync } = require('child_process')
+const { mint } = require('./service-token')
+const { AUTH_PRIVATE_KEY_B64 } = require('./auth-dev-keys')
+
+const containerFor = (service) => `dooer-test-env-${service}-1`
+
+// A service token is accepted by every service and bypasses per-user authorization.
+function serviceToken(serviceId = 'dooer-test-env') {
+  return mint({ serviceId, privateKeyPem: Buffer.from(AUTH_PRIVATE_KEY_B64, 'base64').toString('utf8') })
+}
+
+// The request runs in the target container: payload/token/path go in as env vars (no quoting hazards).
+const REQUEST_SCRIPT = `
+const http = require('http')
+const body = process.env.DTE_BODY || ''
+const req = http.request(
+  {
+    host: 'localhost',
+    port: 3000,
+    method: process.env.DTE_METHOD,
+    path: process.env.DTE_PATH,
+    headers: Object.assign(
+      { authorization: 'Bearer ' + process.env.DTE_TOKEN, 'x-dooer-client': 'dooer-test-env@0' },
+      body ? { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) } : {}
+    ),
+  },
+  (res) => {
+    let d = ''
+    res.on('data', (c) => (d += c))
+    res.on('end', () => {
+      process.stdout.write(JSON.stringify({ status: res.statusCode, body: d }))
+      process.exit(0)
+    })
+  }
+)
+req.on('error', (e) => {
+  process.stdout.write(JSON.stringify({ status: 0, body: String(e.message) }))
+  process.exit(0)
+})
+if (body) req.write(body)
+req.end()
+`
+
+// Perform one request. Returns { status, json }. Throws on a non-2xx (with the service's own error body).
+function apiRequest({ service, method, path, body, token, label }) {
+  const payload = body === undefined ? '' : JSON.stringify(body)
+  const r = spawnSync(
+    'docker',
+    [
+      'exec',
+      '-e',
+      `DTE_METHOD=${method}`,
+      '-e',
+      `DTE_PATH=${path}`,
+      '-e',
+      `DTE_TOKEN=${token}`,
+      '-e',
+      `DTE_BODY=${payload}`,
+      containerFor(service),
+      'node',
+      '-e',
+      REQUEST_SCRIPT,
+    ],
+    { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 }
+  )
+  if (r.status !== 0) {
+    throw new Error(
+      `cannot reach ${service} (is the env up? \`dooer-test-env up\`): ${(r.stderr || '').trim().slice(0, 300)}`
+    )
+  }
+  // The container prints our JSON last; ignore any logging the app wrote to stdout first.
+  const out = (r.stdout || '').trim()
+  const start = out.lastIndexOf('{"status"')
+  let parsed
+  try {
+    parsed = JSON.parse(start >= 0 ? out.slice(start) : out)
+  } catch (_) {
+    throw new Error(`${label || path}: unreadable response from ${service}: ${out.slice(0, 300)}`)
+  }
+  if (parsed.status < 200 || parsed.status >= 300) {
+    throw new Error(`${label || `${method} ${path}`} failed (${parsed.status}): ${String(parsed.body).slice(0, 500)}`)
+  }
+  let json = null
+  try {
+    json = parsed.body ? JSON.parse(parsed.body) : null
+  } catch (_) {
+    /* empty/non-JSON body (e.g. 204) */
+  }
+  return { status: parsed.status, json }
+}
+
+module.exports = { apiRequest, serviceToken, containerFor }

package/lib/command/service.js

@@ -89,7 +89,10 @@ module.exports = {
           if (fs.existsSync(rt.OVERRIDE_FILE))
             ov = yaml.safeLoad(fs.readFileSync(rt.OVERRIDE_FILE, 'utf8')) || { services: {} }
           ov.services = ov.services || {}
-          ov.services[a.name] = { image }
+          // Keep DOOER_SERVICE_VERSION in sync with the tag: the logging library stamps it on every log
+          // line (and the applicationChain), so a bare image bump leaves logs reporting the manifest's
+          // stale version — the same drift deploy-staging.sh exists to prevent.
+          ov.services[a.name] = { image, environment: { DOOER_SERVICE_VERSION: a.tag } }
           rt.ensureRunDir()
           fs.writeFileSync(rt.OVERRIDE_FILE, yaml.safeDump(ov))
           const st = rt.readState()

package/lib/compose/generate.js

@@ -38,6 +38,11 @@ const DEV = {
   sqlPassword: 'dooer',
   minioUser: 'minioadmin',
   minioPassword: 'minioadmin',
+  // Redis MUST have a password locally, like staging (the redis-password secret). service-graphql's
+  // pubsub.js does `password ? createRedisClient(...).then(c => new RedisPubSub(...)) : async () => null`
+  // — with no password it exports a FUNCTION, and `await fn` yields the function itself, so every GraphQL
+  // subscription dies on `pubsubInstance.asyncIterator is not a function`. (Jimmy 2026-09-03.)
+  redisPassword: 'dooer',
 }
 
 // Applied to EVERY dooer service, last, so they win over the manifest values.
@@ -138,7 +143,7 @@ const OMIT = Symbol('omit-env')
 function secretDefault(name) {
   if (name === 'DOOER_SQL_APPLICATION_PASSWORD') return DEV.sqlPassword
   if (name === 'DOOER_SQL_MIGRATION_PASSWORD') return DEV.sqlPassword
-  if (name === 'SECRET_DOOER_REDIS_PASSWORD') return '' // local redis has no auth; empty is the correct value
+  if (name === 'SECRET_DOOER_REDIS_PASSWORD') return DEV.redisPassword // local redis runs with --requirepass
   if (/ACCESS_KEY_ID$/.test(name)) return DEV.minioUser
   if (/SECRET_ACCESS_KEY$/.test(name)) return DEV.minioPassword
   return OMIT
@@ -231,6 +236,8 @@ function infraServices() {
     },
     redis: {
       image: 'redis:7-alpine',
+      // password-protected like staging — see DEV.redisPassword for why it matters (GraphQL subscriptions).
+      command: ['redis-server', '--requirepass', DEV.redisPassword],
       ports: ['6379:6379'],
       restart: 'unless-stopped',
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dooer/dooer-test-env",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Run the whole Dooer backend locally (staging DB minus customers), copy/purge customers between environments, and shred — one CLI.",
   "license": "UNLICENSED",
   "repository": "Dooer/cli-dooer-test-env",