@voxgig/build 4.1.0 → 4.3.0

package/tm/env/server.entry.ts.frag

@@ -0,0 +1,48 @@
+
+// $$Name$$ backend - $$env$$ environment entry (generated once; this file
+// is yours to edit). A long-lived server process using the shared Seneca
+// setup (src/env/shared/basic.ts); reads its env config from the model
+// (main.env.$$env$$).
+
+import Seneca from 'seneca'
+import { Local } from '@voxgig/system'
+
+import { basic, base } from '../shared/basic'
+
+import Pkg from '../../../package.json'
+import Model from '../../../model/model.json'
+
+
+run()
+
+
+async function run() {
+  const { deep } = Seneca.util
+
+  const envdef: any = (Model as any).main.env?.['$$env$$'] || {}
+
+  const seneca = Seneca(deep(base.seneca, {
+    tag: '$$name$$-$$env$$',
+    log: { level: envdef.log || 'warn' },
+  }, envdef.seneca || {}))
+
+  seneca.context.model = Model
+  seneca.context.env = '$$env$$'
+  seneca.context.stage = process.env.STAGE || '$$env$$'
+  seneca.context.srvname = 'all'
+  seneca.context.pkg = Pkg
+
+  basic(seneca)
+
+  seneca.use(Local, {
+    srv: {
+      folder: __dirname + '/../../../dist/srv',
+    },
+  })
+
+  await seneca.ready()
+
+  console.log('$$name$$-backend started', {
+    env: '$$env$$', version: Pkg.version, port: $$port$$,
+  })
+}

package/tm/env/vm/README.md.frag

@@ -0,0 +1,5 @@
+# $$Name$$ - vm environment
+
+Boot any cloud VM with gen/env/vm/cloud-init.yaml as user-data, then push
+code with the basic deploy script (BASIC_HOST=user@vm sh
+gen/env/basic/deploy.sh) or your own pipeline.

package/tm/env/vm/cloud-init.yaml.frag

@@ -0,0 +1,23 @@
+#cloud-config
+# $$Name$$ backend VM bootstrap (generated; customize via tm/env/vm/)
+packages:
+  - nodejs
+  - npm
+  - rsync
+write_files:
+  - path: /etc/systemd/system/$$name$$-backend.service
+    content: |
+      [Unit]
+      Description=$$Name$$ backend
+      After=network.target
+      [Service]
+      WorkingDirectory=/opt/$$name$$/backend
+      ExecStart=/usr/bin/node dist/env/local/local.js
+      Restart=always
+      Environment=NODE_ENV=production
+      [Install]
+      WantedBy=multi-user.target
+runcmd:
+  - mkdir -p /opt/$$name$$/backend
+  - systemctl daemon-reload
+  - systemctl enable $$name$$-backend

package/tm/web/backend/env/web/web.ts.frag

@@ -0,0 +1,120 @@
+
+// Local web runner: the local in-memory backend plus an HTTP layer for
+// the SPA - express serving web/dist, the model, and a single seneca
+// gateway endpoint (/seneca) that the browser-side Seneca bus posts
+// messages to (seneca-browser fetch transport). Cookie auth via
+// @seneca/gateway-auth (express_cookie): signin sets the todo-auth
+// cookie, after which the gateway attaches the principal so @seneca/owner
+// scopes todos per user.
+//
+// Predefined users are seeded at startup (local testing only).
+
+import Path from 'node:path'
+
+import Express from 'express'
+import CookieParser from 'cookie-parser'
+
+import Seneca from 'seneca'
+import { Local } from '@voxgig/system'
+
+import { basic, base } from '../shared/basic'
+
+import Pkg from '../../../package.json'
+import Model from '../../../model/model.json'
+
+
+const PORT = parseInt(process.env.PORT || '', 10) ||
+  (Model as any).main.conf.port.backend
+
+// Predefined users seeded at startup (local testing only). Edit freely.
+const USERS = $$users$$
+
+
+run()
+
+
+async function run() {
+  const { deep } = Seneca.util
+
+  const seneca = Seneca(deep(base.seneca, { tag: '$$name$$-web' }))
+
+  seneca.context.model = Model
+  seneca.context.env = 'local'
+  seneca.context.stage = 'local'
+  seneca.context.srvname = 'all'
+  seneca.context.pkg = Pkg
+
+  seneca.test()
+
+  basic(seneca)
+
+  seneca
+    .use('gateway', {
+      // Allow auth + every service the model declares (aim:<srv>).
+      allow: Object.keys((Model as any).main.srv).reduce(
+        (a: any, n: string) => (a['aim:' + n] = true, a),
+        { 'aim:req,on:auth': true }),
+    })
+    .use('gateway-express', {
+      // gateway-express sets/clears the auth cookie when a result carries
+      // gateway$.auth (see web_signin_user / web_signout_user). Cookie
+      // attributes use the plugin defaults (httpOnly, sameSite).
+      auth: {
+        token: {
+          name: '$$name$$-auth',
+        },
+      },
+    })
+    .use('gateway-auth', {
+      spec: {
+        express_cookie: {
+          active: true,
+          token: {
+            name: '$$name$$-auth',
+          },
+          user: {
+            auth: true,
+            require: false,
+          },
+        },
+      },
+    })
+
+  seneca.use(Local, {
+    srv: {
+      folder: __dirname + '/../../../dist/srv',
+    },
+  })
+
+  await seneca.ready()
+
+  // Seed the predefined users (idempotent per boot: in-memory store).
+  for (const u of USERS) {
+    const res = await seneca.post('sys:user,register:user', u)
+    if (!res.ok) {
+      console.log('SEED-USER-FAILED', u.email, res.why)
+    }
+  }
+
+  const app = Express()
+  // web/ is a sibling of backend/; from dist/env/local go up to the
+  // project root, then web/dist.
+  const webdist = Path.join(
+    __dirname, '..', '..', '..', '..', 'web', 'dist')
+
+  app
+    .use(Express.json())
+    .use(new (CookieParser as any)())
+    .post('/seneca', seneca.export('gateway-express/handler'))
+    .get('/model.json',
+      (_req: any, res: any) => res.sendFile(
+        Path.join(__dirname, '..', '..', '..', 'model', 'model.json')))
+    .use(Express.static(webdist))
+    .listen(PORT)
+
+  console.log('$$name$$-web started', {
+    port: PORT,
+    users: USERS.map((u) => u.email),
+    version: Pkg.version,
+  })
+}

package/tm/web/backend/srv/auth/auth-srv.ts.frag

@@ -0,0 +1,4 @@
+
+import { MakeSrv } from '@voxgig/system'
+
+module.exports = MakeSrv('auth', require)

package/tm/web/backend/srv/auth/get_info.ts.frag

@@ -0,0 +1,5 @@
+module.exports = function make_get_info() {
+  return async function get_info(this: any, _msg: any) {
+    return { ok: true, srv: 'auth' }
+  }
+}

package/tm/web/backend/srv/auth/load_auth.ts.frag

@@ -0,0 +1,6 @@
+module.exports = function make_load_auth() {
+  return async function load_auth(this: any, msg: any) {
+    const user = await this.entity('sys/user').load$(msg.user_id)
+    return { ok: !!user, state: user ? 'signedin' : 'signedout', user }
+  }
+}

package/tm/web/backend/srv/auth/signin_user.ts.frag

@@ -0,0 +1,14 @@
+// Sign a user in via @seneca/user login (email + password).
+module.exports = function make_signin_user() {
+  return async function signin_user(this: any, msg: any) {
+    const seneca = this
+
+    const out = await seneca.post('sys:user,login:user', {
+      email: msg.email,
+      password: msg.password,
+      fields: ['id', 'email', 'name', 'handle'],
+    })
+
+    return out
+  }
+}

package/tm/web/backend/srv/auth/signout_user.ts.frag

@@ -0,0 +1,5 @@
+module.exports = function make_signout_user() {
+  return async function signout_user(this: any, msg: any) {
+    return this.post('sys:user,logout:user', { token: msg.token })
+  }
+}

package/tm/web/backend/srv/auth/web_load_auth.ts.frag

@@ -0,0 +1,12 @@
+// Current auth state, from the principal the gateway resolved (cookie).
+module.exports = function make_web_load_auth() {
+  return async function web_load_auth(this: any, _msg: any, meta: any) {
+    const user = meta.custom?.principal?.user
+    const out: any = { ok: true, state: 'signedout' }
+    if (user) {
+      out.state = 'signedin'
+      out.user = { id: user.id, email: user.email, handle: user.handle }
+    }
+    return out
+  }
+}

package/tm/web/backend/srv/auth/web_signin_user.ts.frag

@@ -0,0 +1,25 @@
+// Gateway signin: on success the gateway$ auth token result field makes
+// gateway-auth (express_cookie) set the auth cookie.
+module.exports = function make_web_signin_user() {
+  return async function web_signin_user(this: any, msg: any) {
+    const res = await this.post('aim:auth,signin:user', {
+      email: msg.email,
+      password: msg.password,
+    })
+
+    const out: any = { ok: res.ok }
+    if (res.ok) {
+      out.gateway$ = { auth: { token: res.login.token } }
+      out.user = {
+        id: res.user.id,
+        email: res.user.email,
+        name: res.user.name,
+        handle: res.user.handle,
+      }
+    }
+    else {
+      out.why = res.why
+    }
+    return out
+  }
+}

package/tm/web/backend/srv/auth/web_signout_user.ts.frag

@@ -0,0 +1,9 @@
+module.exports = function make_web_signout_user() {
+  return async function web_signout_user(this: any, _msg: any, meta: any) {
+    const token = meta.custom?.principal?.token
+    if (token) {
+      await this.post('aim:auth,signout:user', { token })
+    }
+    return { ok: true, gateway$: { auth: { remove: true } } }
+  }
+}

package/tm/web/web/e2e/smoke.spec.js.frag

@@ -0,0 +1,21 @@
+import { test, expect } from '@playwright/test'
+
+// Generic smoke test: the SPA boots, a seeded user can sign in, and the
+// model-driven entity admin renders with at least one entity. Add
+// project-specific CRUD flows alongside this file.
+
+test('sign in and load the entity admin', async ({ page }) => {
+  await page.goto('/')
+
+  await expect(page.locator('vg-auth h2')).toHaveText('Sign in')
+
+  await page.fill('input[name=email]', '$$seedEmail$$')
+  await page.fill('input[name=password]', '$$seedPassword$$')
+  await page.click('vg-auth button[type=submit]')
+
+  await expect(page.locator('.vg-auth-bar b')).toHaveText('$$seedEmail$$')
+  await expect(page.locator('vg-entity-admin nav a')).not.toHaveCount(0)
+
+  // The first entity's list loads (count line rendered).
+  await expect(page.locator('#vg-count')).toBeVisible()
+})

package/tm/web/web/index.html.frag

@@ -0,0 +1,13 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>$$Name$$</title>
+    <script src="/seneca-browser.js"></script>
+  </head>
+  <body>
+    <vg-app></vg-app>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>

package/tm/web/web/package.json.frag

@@ -0,0 +1,17 @@
+{
+  "name": "$$name$$-web",
+  "version": "0.1.0",
+  "private": true,
+  "description": "$$Name$$ SPA: web components on a Seneca service bus",
+  "scripts": {
+    "postinstall": "node -e \"require('fs').copyFileSync(require.resolve('seneca-browser'),'public/seneca-browser.js')\"",
+    "dev": "vite",
+    "build": "vite build",
+    "e2e": "playwright test"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.2",
+    "seneca-browser": "^8.0.0-rc4",
+    "vite": "^7.3.4"
+  }
+}

package/tm/web/web/playwright.config.js.frag

@@ -0,0 +1,36 @@
+// Headless-chrome E2E for the $$Name$$ SPA. The backend web runner (which
+// serves the built SPA and the /seneca gateway) is started as the test
+// webServer; Playwright waits for it, then drives the SPA.
+import { defineConfig, devices } from '@playwright/test'
+
+const PORT = $$e2eport$$
+
+export default defineConfig({
+  testDir: './e2e',
+  timeout: 30000,
+  fullyParallel: false,
+  reporter: [['list']],
+  use: {
+    baseURL: `http://localhost:${PORT}`,
+    trace: 'off',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+        // Self-contained chromium (no system chrome / no desktop): install
+        // with `npx playwright install chromium` (no --with-deps).
+        launchOptions: { args: ['--no-sandbox'] },
+      },
+    },
+  ],
+  webServer: {
+    command: `npm run build && cd ../backend && PORT=${PORT} node dist/env/web/web.js`,
+    url: `http://localhost:${PORT}/`,
+    timeout: 60000,
+    reuseExistingServer: false,
+    stdout: 'ignore',
+    stderr: 'pipe',
+  },
+})

package/tm/web/web/src/bus.js.frag

@@ -0,0 +1,61 @@
+// The browser-side Seneca service bus. All component state and all
+// backend communication flow through messages on this bus:
+//
+//   aim:*             -> the backend gateway (/seneca) via the
+//                        seneca-browser fetch transport (cookie auth)
+//   cmp:*             -> local component plugins (state)
+//
+// Cross-component notification uses the tiny `evt` plugin below:
+// components post cmp:bus,emit:<name> and subscribe with onEvent().
+
+/* global Seneca */
+
+const bus = Seneca({
+  legacy: false,
+  timeout: 8888,
+  plugin: {
+    browser: {
+      endpoint: '/seneca',
+      fetch: {
+        credentials: 'same-origin',
+      },
+    },
+  },
+})
+  .test()
+  .client({ type: 'browser', pin: 'aim:*' })
+
+
+// Event fanout: seneca actions have single handlers, so the bus plugin
+// keeps a listener registry for UI notification.
+const listeners = {}
+
+bus.use(function evt() {
+  this.add('cmp:bus,emit:evt', function (msg, reply) {
+    const subs = listeners[msg.name] || []
+    for (const fn of subs) {
+      try {
+        fn(msg.data || {})
+      }
+      catch (e) {
+        console.error('evt listener failed', msg.name, e)
+      }
+    }
+    reply({ ok: true, count: subs.length })
+  })
+})
+
+function onEvent(name, fn) {
+  (listeners[name] = listeners[name] || []).push(fn)
+}
+
+function emit(name, data) {
+  bus.post('cmp:bus,emit:evt', { name, data })
+}
+
+
+export {
+  bus,
+  onEvent,
+  emit,
+}