create-protobase 0.23.13 → 0.24.0

package/dist/templates/erp/config/jobs.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+import type { WriteEvent } from '@protobase/server'
+import { overdueCheck } from './jobs'
+
+const event = (operation: WriteEvent['operation'], after?: Record<string, unknown>, resource = 'invoices') =>
+  ({ operation, resource: { name: resource }, user: { id: 1, roles: [] }, ...(after && { after }) }) as unknown as WriteEvent
+
+describe('overdueCheck', () => {
+  it('checks a sent invoice the day after it is due, once per invoice', () => {
+    expect(overdueCheck(event('update', { id: '42', status: 'sent', due_at: '2026-11-01' }))).toEqual({
+      invoiceId: '42',
+      runAt: new Date('2026-11-02T00:00:00Z'),
+      key: 'invoice:42',
+    })
+  })
+
+  it('leaves drafts, paid invoices, deletes and other resources alone', () => {
+    expect(overdueCheck(event('create', { id: '1', status: 'draft', due_at: '2026-11-01' }))).toBeUndefined()
+    expect(overdueCheck(event('update', { id: '1', status: 'paid', due_at: '2026-11-01' }))).toBeUndefined()
+    expect(overdueCheck(event('delete'))).toBeUndefined()
+    expect(overdueCheck(event('update', { id: '1', status: 'sent' }, 'orders'))).toBeUndefined()
+  })
+})

package/dist/templates/erp/config/jobs.ts

@@ -0,0 +1,29 @@
+import { sql } from 'kysely'
+import { defineJob, type WriteEvent } from '@protobase/server'
+
+/** An invoice still sent and unpaid once its due date has passed becomes overdue. */
+export const markInvoiceOverdue = defineJob<{ invoiceId: string }>({
+  name: 'mark-invoice-overdue',
+  run: async ({ invoiceId }, { db }) => {
+    await sql`update sales.invoices set status = 'overdue' where id = ${invoiceId} and status = 'sent' and due_at < current_date`.execute(db)
+  },
+})
+
+/** Every night, the sent invoices that passed their due date, such as imported ones that never had a check enqueued. */
+export const markOverdueInvoices = defineJob({
+  name: 'mark-overdue-invoices',
+  schedule: '0 2 * * *',
+  timezone: 'Europe/Amsterdam',
+  run: async (_, { db }) => {
+    await sql`update sales.invoices set status = 'overdue' where status = 'sent' and due_at < current_date`.execute(db)
+  },
+})
+
+const day = 86_400_000
+
+/** For a sent invoice, the check that it is paid: the day after it is due, one waiting check per invoice. */
+export const overdueCheck = (event: WriteEvent) => {
+  if (event.resource.name !== 'invoices' || event.operation === 'delete' || event.after?.status !== 'sent') return undefined
+  const invoiceId = String(event.after.id)
+  return { invoiceId, runAt: new Date(Date.parse(String(event.after.due_at)) + day), key: `invoice:${invoiceId}` }
+}

package/dist/templates/erp/config/locations/data.ts

@@ -0,0 +1,18 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** inventory.locations. Unique: (warehouse_id, path) */
+export const locations = resource('locations')
+  .table('inventory.locations')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    warehouse_id: f.relation('warehouses').filterable().sortable(),
+    path: f.text().readOnly().filterable(),
+    name: f.text(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('locations'))

package/dist/templates/erp/config/locations/ui.ts

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { locations } from './data'
+
+export const locationsView = view<typeof locations>('locations')
+  .names({ singular: 'Location', plural: 'Locations' })
+  .list((r) => ({ columns: [r.path, r.name, r.warehouse_id] }))

package/dist/templates/erp/config/order_lines/data.ts

@@ -0,0 +1,20 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** sales.order_lines */
+export const orderLines = resource('order_lines')
+  .table('sales.order_lines')
+  .fields({
+    order_id: f.relation('orders').filterable().sortable(),
+    line_no: f.integer().sortable(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    product_id: f.relation('products').filterable().sortable(),
+    description: f.text(),
+    quantity: f.integer(),
+    unit_price: f.decimal({ precision: 12, scale: 2 }),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => [r.order_id, r.line_no])
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('order_lines'))

package/dist/templates/erp/config/order_lines/ui.ts

@@ -0,0 +1,7 @@
+import { view } from '@protobase/schema'
+import type { orderLines } from './data'
+
+export const orderLinesView = view<typeof orderLines>('order_lines')
+  .nav({ hidden: true })
+  .names({ singular: 'Order line', plural: 'Order lines' })
+  .list((r) => ({ columns: [r.quantity, r.unit_price, r.product_id] }))

package/dist/templates/erp/config/orders/data.ts

@@ -0,0 +1,27 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** sales.orders. Unique: (organization_id, number) */
+export const orders = resource('orders')
+  .table('sales.orders')
+  .fields({
+    id: f.uuid().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    number: f.text().filterable().sortable(),
+    company_id: f.relation('companies').filterable().sortable(),
+    person_id: f.relation('people').optional().filterable().sortable(),
+    owner_id: f.relation('users').filterable().sortable(),
+    status: f.enum(['draft', 'confirmed', 'picking', 'shipped', 'delivered', 'cancelled']).filterable().sortable(),
+    currency_code: f.relation('currencies'),
+    discount_percent: f.decimal({ precision: 5, scale: 2 }).default('0'),
+    total: f.decimal({ precision: 14, scale: 2 }).readOnly().default('0').filterable().sortable(),
+    paid: f.boolean().default(false).filterable().sortable(),
+    notes: f.text().optional(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .owner((r) => r.owner_id)
+  .search((r) => [r.number])
+  .access(erpAccess('orders'))

package/dist/templates/erp/config/orders/ui.ts

@@ -0,0 +1,41 @@
+import { view } from '@protobase/schema'
+import type { orders } from './data'
+
+export const ordersView = view<typeof orders>('orders')
+  .title((r) => r.number)
+  .names({ singular: 'Order', plural: 'Orders' })
+  .nav({
+    recent: {
+      status: 'status',
+      tones: { draft: 'neutral', confirmed: 'info', picking: 'warning', shipped: 'success' },
+      pulse: ['picking'],
+      filter: 'status != "delivered" AND status != "cancelled"',
+      orderBy: 'created_at desc',
+    },
+  })
+  .fields((r) => ({
+    status: r.status.help('Where the order is in its life. Moving it forward can notify the customer.').format('badge')
+      .valueLabels({ draft: 'Draft', confirmed: 'Confirmed', picking: 'Picking', shipped: 'Shipped', delivered: 'Delivered', cancelled: 'Cancelled' }),
+    total: r.total.help('Order total including VAT.').prefix('€').decimals(2),
+    discount_percent: r.discount_percent.label('Discount').help('Percentage taken off the order total.').format('percent'),
+    paid: r.paid.help('Set when the payment has been received.'),
+    created_at: r.created_at.label('Created').format('absolute'),
+  }))
+  .list((r) => ({
+    columns: [r.number, r.company_id, r.status, r.total, r.discount_percent, r.paid, r.owner_id, r.created_at],
+    sort: [[r.created_at, 'desc']],
+    search: [r.number],
+  }))
+  .filters((r, w) => [
+    w.facets(r.status),
+    w.facets(r.owner_id),
+    w.dateRange(r.created_at, { presets: ['7d', '30d', '90d', 'quarter', 'year'] }),
+    w.range(r.total, { histogram: true }),
+    w.toggle(r.paid),
+  ])
+  .chart((r) => ({ field: r.created_at, range: '30d', granularity: 'day' }))
+  .saveFeedback('toast')
+  .actions((a) => [
+    a.update('markPaid', { label: 'Mark as paid', icon: 'wallet', set: { paid: true }, confirm: 'Record that the customer paid this order?' }),
+    a.action('createInvoice', { label: 'Create invoice', icon: 'file-text' }),
+  ])

package/dist/templates/erp/config/organizations/data.ts

@@ -0,0 +1,17 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** core.organizations. Unique: (slug) */
+export const organizations = resource('organizations')
+  .table('core.organizations')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    name: f.text(),
+    slug: f.text().filterable().sortable(),
+    country_code: f.relation('countries').filterable().sortable(),
+    currency_code: f.relation('currencies').filterable().sortable(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .access(erpAccess('organizations'))

package/dist/templates/erp/config/organizations/ui.ts

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { organizations } from './data'
+
+export const organizationsView = view<typeof organizations>('organizations')
+  .names({ singular: 'Organization', plural: 'Organizations' })
+  .list((r) => ({ columns: [r.name, r.slug, r.country_code, r.currency_code] }))

package/dist/templates/erp/config/overview/page.tsx

@@ -0,0 +1,80 @@
+/** @jsxImportSource @protobase/layout */
+import { Action, Card, CardRow, Chart, Field, Grid, ModalForm, Page, RecordCard, Show, Stat, Table, component, page } from '@protobase/layout'
+
+/** Orders per day for the last `days` days, drawn by protobase.ui.tsx. */
+export const OrdersPerDay = component<{ days: 7 | 30 | 90 }>('OrdersPerDay')
+
+/** The sales team's start page: what needs attention today, and the leads to follow up. */
+export const salesOverview = page(
+  'overview',
+  <Page title="Sales overview" description="What needs attention today: unpaid orders, overdue invoices and new leads.">
+    <Show when="orders.count = 0">
+      <Card title="No orders yet">Create the first order from Orders; this page fills up as the team sells.</Card>
+    </Show>
+    <Grid columns={4}>
+      <Stat label="Draft orders" resource="orders" filter="status = 'draft'" />
+      <Stat label="Delivered, not paid" resource="orders" filter="status = 'delivered' AND paid = false" />
+      <Stat label="Overdue invoices" resource="invoices" filter="status = 'overdue'" />
+      <Stat label="Open leads" resource="companies" filter="status = 'lead'" />
+    </Grid>
+    <Grid columns={3}>
+      <RecordCard
+        title="Biggest unpaid delivery"
+        resource="orders"
+        filter="status = 'delivered' AND paid = false"
+        sort="total desc"
+        empty="Every delivered order is paid."
+        actions={<Action name="markPaid" variant="primary" />}
+      >
+        <Grid columns={2}>
+          <Field name="number" />
+          <Field name="total" />
+          <Field name="company_id" label="Customer" />
+          <Field name="company_id.city" label="City" />
+        </Grid>
+        <Show when="company_id.status = 'dormant'">The customer has gone quiet: call before sending a reminder.</Show>
+      </RecordCard>
+      <RecordCard
+        title="Oldest overdue invoice"
+        resource="invoices"
+        filter="status = 'overdue'"
+        sort="issued_at"
+        empty="Nothing is overdue."
+        actions={[<Action name="send" label="Send reminder" />, <Action name="recordPayment" variant="primary" />]}
+      >
+        <Grid columns={2}>
+          <Field name="number" />
+          <Field name="total" />
+          <Field name="company_id" label="Customer" />
+          <Field name="due_at" label="Due" />
+        </Grid>
+      </RecordCard>
+      <Card title="Orders per day" description="The last 30 days.">
+        <OrdersPerDay days={30} />
+      </Card>
+    </Grid>
+    <Grid columns={2}>
+      <Chart title="Orders by status" resource="orders" groupBy="status" type="donut" />
+      <Chart title="Revenue by customer" description="Orders not cancelled." resource="orders" groupBy="company_id" sum="total" filter="status != 'cancelled'" limit={5} />
+    </Grid>
+    <Grid columns={2}>
+      <Table title="Overdue invoices" resource="invoices" filter="status = 'overdue'" sort="issued_at" columns={['number', 'company_id', 'due_at', 'total']} limit={5} empty="Nothing is overdue." />
+      <Table title="Latest orders" resource="orders" sort="created_at desc" columns={['number', 'company_id', 'status', 'total']} limit={5} />
+    </Grid>
+    <CardRow
+      title="New leads"
+      description="Companies that have not ordered yet."
+      resource="companies"
+      filter="status = 'lead'"
+      sort="created_at desc"
+      limit={8}
+      actions={<ModalForm mode="create" label="Add lead" resource="companies" fields={['name', 'city', 'country_code', 'email']} values={{ status: 'lead' }} />}
+    >
+      <Field name="name" label={false} />
+      <Field name="city" />
+      <Field name="email" />
+      <ModalForm mode="edit" label="Edit" fields={['name', 'city', 'email', 'phone', 'status']} />
+    </CardRow>
+  </Page>,
+  { nav: { group: 'Sales', order: 0 }, icon: 'layout-dashboard' },
+)

package/dist/templates/erp/config/pages.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+import { checkPages } from '@protobase/layout'
+import { configExports } from '@protobase/server'
+import * as config from './index'
+
+describe('ERP pages', () => {
+  it('name only resources, fields, filters and actions the ERP has', () => {
+    const { resources, views, pages } = configExports(config)
+    const models = Object.fromEntries(resources.map((source) => [source.toModel().name, source.toModel()]))
+    const actions = (resource: string) => new Set(views.map((view) => view.toModel()).filter((view) => view.resource === resource).flatMap((view) => view.actions.map((action) => action.name)))
+    expect(pages.map((entry) => entry.name)).toEqual(['accounts', 'overview'])
+    expect(() => checkPages(pages.map((entry) => entry.toModel()), { models, actions })).not.toThrow()
+  })
+})

package/dist/templates/erp/config/people/data.ts

@@ -0,0 +1,21 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** crm.people */
+export const people = resource('people')
+  .table('crm.people')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    company_id: f.relation('companies').filterable().sortable(),
+    first_name: f.text(),
+    last_name: f.text(),
+    email: f.text().optional(),
+    phone: f.text().optional(),
+    job_title: f.text().optional(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('people'))

package/dist/templates/erp/config/people/ui.ts

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { people } from './data'
+
+export const peopleView = view<typeof people>('people')
+  .names({ singular: 'People', plural: 'People' })
+  .list((r) => ({ columns: [r.first_name, r.last_name, r.email, r.phone, r.job_title] }))

package/dist/templates/erp/config/products/data.ts

@@ -0,0 +1,25 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** catalog.products. Unique: (organization_id, sku) */
+export const products = resource('products')
+  .table('catalog.products')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    category_id: f.relation('categories').filterable().sortable(),
+    sku: f.text().filterable().sortable(),
+    name: f.text().filterable(),
+    description: f.text().optional(),
+    price: f.decimal({ precision: 12, scale: 2 }),
+    currency_code: f.relation('currencies'),
+    attributes: f.json().dbDefault(),
+    active: f.boolean().default(true),
+    deleted_at: f.timestamp().optional(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .softDelete((r) => r.deleted_at)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('products'))

package/dist/templates/erp/config/products/ui.ts

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { products } from './data'
+
+export const productsView = view<typeof products>('products')
+  .names({ singular: 'Product', plural: 'Products' })
+  .list((r) => ({ columns: [r.sku, r.name, r.price, r.active] }))

package/dist/templates/erp/config/roles.test.ts

@@ -0,0 +1,56 @@
+import { resolveAccess } from '@protobase/schema'
+import { describe, expect, it } from 'vitest'
+import { empMaster, orders, stockMoves } from './index'
+
+const as = (role: string) => ({ user: { id: 3, roles: [role] } })
+
+describe('ERP roles on orders', () => {
+  const rows = [
+    // role, read, create, update, delete, read filter, update filter
+    ['admin', true, true, true, true, undefined, undefined],
+    ['auditor', true, false, false, false, undefined, undefined],
+    ['manager', true, true, true, false, undefined, undefined],
+    ['sales', true, true, true, false, 'compare', 'compare'],
+    ['accountant', true, false, false, false, undefined, undefined],
+    ['warehouse', true, false, true, false, undefined, undefined],
+    ['editor', false, false, false, false, undefined, undefined],
+    ['integration', true, true, false, false, undefined, undefined],
+  ] as const
+
+  it.each(rows)('%s', async (role, read, create, update, remove, readFilter, updateFilter) => {
+    const access = await resolveAccess(orders, as(role))
+    expect(access.operations).toEqual({ list: read, read, create, update, delete: remove })
+    expect(access.rowFilter.read?.kind).toBe(readFilter)
+    expect(access.rowFilter.update?.kind).toBe(updateFilter)
+    if (readFilter) expect(access.rowFilter.read).toMatchObject({ field: { name: 'owner_id' }, value: { value: 3 } })
+    expect(access.readableFields.length > 0).toBe(read)
+  })
+})
+
+describe('hidden columns', () => {
+  // accountant holds costs.read but has no access to stock_moves at all
+  const unitCost = [
+    ['admin', true], ['auditor', true], ['manager', true], ['accountant', false],
+    ['sales', false], ['warehouse', false], ['editor', false], ['integration', false],
+  ] as const
+
+  it.each(unitCost)('stock_moves.unit_cost for %s: %s', async (role, visible) => {
+    const access = await resolveAccess(stockMoves, as(role))
+    expect(access.readableFields.includes('unit_cost')).toBe(visible)
+    if (role === 'warehouse') expect(access.readableFields).toContain('quantity')
+  })
+
+  it.each(['admin', 'auditor', 'manager', 'accountant', 'sales', 'warehouse', 'editor', 'integration'])(
+    'emp_master.sal_amt for %s is admin only',
+    async (role) => {
+      const access = await resolveAccess(empMaster, as(role))
+      expect(access.readableFields.includes('sal_amt')).toBe(role === 'admin')
+      if (role === 'manager') expect(access.readableFields).toContain('emp_name')
+    },
+  )
+
+  it('a field with only a read rule follows its resource for writes', async () => {
+    const access = await resolveAccess(stockMoves, as('warehouse'))
+    expect(access.writableFields.create).toContain('unit_cost')
+  })
+})

package/dist/templates/erp/config/roles.ts

@@ -0,0 +1,54 @@
+import { defineRoles } from '@protobase/schema'
+
+/** Resources plus the area that gates hidden columns. */
+export type ErpName =
+  | 'categories' | 'products' | 'countries' | 'currencies' | 'organizations' | 'users'
+  | 'companies' | 'company_tags' | 'people' | 'tags' | 'emp_master' | 'locations'
+  | 'stock_levels' | 'stock_moves' | 'warehouses' | 'invoice_lines' | 'invoices'
+  | 'order_lines' | 'orders'
+  | 'costs'
+
+/**
+ * Capabilities are `<resource|area>.<action>[.<scope>]`. `.own` rows are those whose `.owner()`
+ * field is the user's id. The `costs` area gates cost columns; salaries are admin-only via `roles.is('admin')`.
+ */
+export const roles = defineRoles<ErpName>({
+  admin: ['*'],
+  auditor: ['*.read'],
+  manager: ['*.read', '*.create', '*.update', 'costs.read'],
+  sales: [
+    'orders.read.own', 'orders.create', 'orders.update.own',
+    'order_lines.read', 'order_lines.create', 'order_lines.update', 'order_lines.delete',
+    'companies.read', 'companies.create', 'companies.update',
+    'people.read', 'people.create', 'people.update',
+    'company_tags.read', 'company_tags.create', 'company_tags.delete', 'tags.read',
+    'products.read', 'categories.read', 'countries.read', 'currencies.read', 'stock_levels.read',
+  ],
+  accountant: [
+    'invoices.*', 'invoice_lines.*',
+    'orders.read', 'order_lines.read', 'companies.read',
+    'products.read', 'categories.read', 'countries.read', 'currencies.read',
+    'costs.read',
+  ],
+  warehouse: [
+    'stock_levels.*', 'stock_moves.*', 'locations.*', 'warehouses.read',
+    'orders.read', 'orders.update', 'order_lines.read',
+    'products.read', 'categories.read',
+  ],
+  editor: [
+    'products.*', 'categories.*', 'tags.*', 'company_tags.*',
+    'countries.read', 'currencies.read',
+  ],
+  integration: [
+    'orders.read', 'orders.create', 'order_lines.read', 'order_lines.create',
+    'products.read', 'companies.read', 'stock_levels.read',
+  ],
+})
+
+/** The standard rule set for a resource: every operation needs the matching capability. */
+export const erpAccess = (name: ErpName) => ({
+  read: roles.can(`${name}.read`),
+  create: roles.can(`${name}.create`),
+  update: roles.can(`${name}.update`),
+  delete: roles.can(`${name}.delete`),
+})

package/dist/templates/erp/config/shell.test.ts

@@ -0,0 +1,24 @@
+import { createAdmin, configExports } from '@protobase/server'
+import { describe, expect, it } from 'vitest'
+import * as config from './index'
+import { roles } from './roles'
+
+describe('ERP sidebar, user menu and bottom bar', () => {
+  const { resources, views, pages, userMenu, bottomBars } = configExports(config)
+
+  it('has recent groups that fit their resources', () => {
+    const grouped = views.map((view) => view.toModel()).filter((view) => view.nav?.recent)
+    expect(grouped.map((view) => view.resource).sort()).toEqual(['invoices', 'orders'])
+    // createAdmin refuses a group or a user menu entry that does not fit, before any request.
+    expect(() => createAdmin({ resources, views, pages, userMenu, db: {} as never, authenticate: () => { throw new Error('No requests in this test') } })).not.toThrow()
+  })
+
+  it('moves the account pages into the user menu', () => {
+    expect(userMenu?.toUserMenuModel().items.map((item) => (item.kind === 'resource' ? item.resource : item.kind === 'page' ? item.page : item.label))).toEqual(['organizations', 'accounts', 'Documentation', 'Support'])
+  })
+
+  it('gives the warehouse role a bottom bar that fits the resources and roles', () => {
+    expect(bottomBars.map((bar) => bar.toBottomBarModel())).toEqual([expect.objectContaining({ label: 'Warehouse', roles: ['warehouse'] })])
+    expect(() => createAdmin({ resources, views, bottomBars, db: {} as never, authenticate: () => { throw new Error('No requests in this test') }, options: { roles } })).not.toThrow()
+  })
+})

package/dist/templates/erp/config/stock_levels/data.ts

@@ -0,0 +1,16 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** inventory.stock_levels */
+export const stockLevels = resource('stock_levels')
+  .table('inventory.stock_levels')
+  .fields({
+    product_id: f.relation('products').filterable().sortable(),
+    location_id: f.relation('locations').filterable().sortable(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    quantity: f.integer(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => [r.product_id, r.location_id])
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('stock_levels'))

package/dist/templates/erp/config/stock_levels/ui.ts

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { stockLevels } from './data'
+
+export const stockLevelsView = view<typeof stockLevels>('stock_levels')
+  .names({ singular: 'Stock level', plural: 'Stock levels' })
+  .list((r) => ({ columns: [r.quantity] }))

package/dist/templates/erp/config/stock_moves/data.ts

@@ -0,0 +1,22 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess, roles } from '../roles'
+
+/** inventory.stock_moves */
+export const stockMoves = resource('stock_moves')
+  .table('inventory.stock_moves')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    product_id: f.relation('products').filterable().sortable(),
+    warehouse_id: f.relation('warehouses').filterable().sortable(),
+    location_id: f.relation('locations').filterable().sortable(),
+    kind: f.enum(['receipt', 'issue', 'transfer', 'adjustment']).filterable().sortable(),
+    quantity: f.integer().filterable().sortable(),
+    unit_cost: f.decimal({ precision: 12, scale: 2 }).access({ read: roles.can('costs.read') }),
+    reference: f.text().optional(),
+    moved_at: f.timestamp().filterable().sortable(),
+    user_id: f.relation('users').optional().filterable().sortable(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('stock_moves'))

package/dist/templates/erp/config/stock_moves/ui.ts

@@ -0,0 +1,25 @@
+import { view } from '@protobase/schema'
+import type { stockMoves } from './data'
+
+export const stockMovesView = view<typeof stockMoves>('stock_moves')
+  .names({ singular: 'Stock move', plural: 'Stock moves' })
+  .fields((r) => ({
+    moved_at: r.moved_at.label('Moved at').format('absolute'),
+    product_id: r.product_id.label('Product'),
+    kind: r.kind.label('Type').help('Receipts add stock, issues remove it, transfers move it between locations.').format('badge').valueLabels({ receipt: 'Receipt', issue: 'Issue', transfer: 'Transfer', adjustment: 'Adjustment' }),
+    quantity: r.quantity.help('Negative for issues.'),
+    warehouse_id: r.warehouse_id.label('Warehouse'),
+    unit_cost: r.unit_cost.label('Unit cost').prefix('€').decimals(2),
+    user_id: r.user_id.label('By'),
+  }))
+  .list((r) => ({
+    columns: [r.moved_at, r.product_id, r.kind, r.quantity, r.warehouse_id, r.unit_cost, r.reference, r.user_id],
+    sort: [[r.moved_at, 'desc']],
+  }))
+  .filters((r, w) => [
+    w.facets(r.kind),
+    w.facets(r.warehouse_id),
+    w.dateRange(r.moved_at, { presets: ['7d', '30d', '90d', 'quarter', 'year'] }),
+    w.range(r.quantity, { histogram: true }),
+  ])
+  .chart((r) => ({ field: r.moved_at, range: '30d', granularity: 'day' }))

package/dist/templates/erp/config/tags/data.ts

@@ -0,0 +1,17 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** crm.tags. Unique: (organization_id, name) */
+export const tags = resource('tags')
+  .table('crm.tags')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    name: f.text().filterable().sortable(),
+    color: f.text(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('tags'))

package/dist/templates/erp/config/tags/ui.ts

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { tags } from './data'
+
+export const tagsView = view<typeof tags>('tags')
+  .names({ singular: 'Tag', plural: 'Tags' })
+  .list((r) => ({ columns: [r.name, r.color] }))

package/dist/templates/erp/config/user-menu.ts

@@ -0,0 +1,9 @@
+import { userMenu } from '@protobase/schema'
+
+/** Account pages under the signed-in user instead of in the sidebar, then help. */
+export const accountMenu = userMenu((m) => [
+  m.resource('organizations', { label: 'Organization', icon: 'building' }),
+  m.page('accounts', { label: 'Users', icon: 'users' }),
+  m.link('Documentation', 'https://docs.protobase.net', { icon: 'book-open' }),
+  m.link('Support', 'mailto:support@example.com', { icon: 'life-buoy' }),
+])

package/dist/templates/erp/config/users/data.ts

@@ -0,0 +1,19 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** core.users. Unique: (organization_id, email) */
+export const users = resource('users')
+  .table('core.users')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    email: f.text().filterable().sortable(),
+    name: f.text(),
+    role: f.enum(['admin', 'sales', 'finance', 'warehouse']).optional().filterable().sortable(),
+    active: f.boolean().default(true),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('users'))