create-protobase 0.23.13 → 0.23.14

package/dist/ask-preset.js

@@ -0,0 +1,25 @@
+import { createInterface } from "node:readline/promises";
+//#region src/ask-preset.ts
+/** The preset for an answer: its number in `names` or its name, the first one when the answer is empty. */
+const presetForAnswer = (names, answer) => {
+	const text = answer.trim();
+	if (text === "") return names[0];
+	const index = Number(text);
+	if (Number.isInteger(index) && index >= 1 && index <= names.length) return names[index - 1];
+	return names.find((name) => name === text);
+};
+const menu = (names) => `Which preset do you want to start from?\n${names.map((name, i) => `  ${i + 1}. ${name}${i === 0 ? " (default)" : ""}\n`).join("")}`;
+/** Asks in the terminal which of `names` to start from, again until the answer is one of them. */
+const askPreset = async (names) => {
+	const prompt = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	process.stdout.write(menu(names));
+	let picked;
+	while (!picked) picked = presetForAnswer(names, await prompt.question(`Preset [1-${names.length}]: `));
+	prompt.close();
+	return picked;
+};
+//#endregion
+export { askPreset, presetForAnswer };

package/dist/create-project.js

@@ -2,19 +2,20 @@ import path from "node:path";
 import { cpSync, existsSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 //#region src/create-project.ts
 /**
-* Writes a new project to `targetDir` from `templateDir`, which the build writes from the scratch preset, with its
-* package.json named after the folder. The folder may exist only when it is empty.
+* Writes a new project to `targetDir` from `templateDir`, which the build writes from a preset, with its package.json
+* named after the folder, and returns that package.json. The folder may exist only when it is empty.
 */
 const createProject = (templateDir, targetDir) => {
 	if (existsSync(targetDir) && readdirSync(targetDir).length > 0) throw new Error(`${targetDir} is not empty`);
 	cpSync(templateDir, targetDir, { recursive: true });
 	for (const file of readdirSync(targetDir).filter((file) => file.startsWith("_"))) renameSync(path.join(targetDir, file), path.join(targetDir, file.slice(1)));
 	const packageFile = path.join(targetDir, "package.json");
-	const manifest = JSON.parse(readFileSync(packageFile, "utf8"));
-	writeFileSync(packageFile, `${JSON.stringify({
-		...manifest,
+	const manifest = {
+		...JSON.parse(readFileSync(packageFile, "utf8")),
 		name: path.basename(targetDir)
-	}, null, 2)}\n`);
+	};
+	writeFileSync(packageFile, `${JSON.stringify(manifest, null, 2)}\n`);
+	return manifest;
 };
 //#endregion
 export { createProject };

package/dist/index.js

@@ -1,23 +1,33 @@
+import { askPreset } from "./ask-preset.js";
 import { createProject } from "./create-project.js";
 import { nextSteps } from "./next-steps.js";
+import { checkPreset, defaultPreset, presetNames } from "./presets.js";
 import path from "node:path";
 import { parseArgs } from "node:util";
 //#region src/index.ts
-const templateDir = path.join(import.meta.dirname, "template");
-const usage = "usage: npm create protobase <dir>";
-const create = (argv) => {
-	const { positionals } = parseArgs({
+const templatesDir = path.join(import.meta.dirname, "templates");
+const usage = "usage: npm create protobase <dir> [-- --preset <name>]";
+const pickPreset = async (flag) => {
+	const names = presetNames(templatesDir);
+	if (flag !== void 0) return checkPreset(names, flag);
+	if (process.stdin.isTTY && process.stdout.isTTY) return askPreset(names);
+	return defaultPreset;
+};
+const create = async (argv) => {
+	const { values, positionals } = parseArgs({
 		args: argv.slice(2),
-		allowPositionals: true
+		allowPositionals: true,
+		options: { preset: { type: "string" } }
 	});
 	const [dir, ...extra] = positionals;
 	if (!dir || extra.length > 0) throw new Error(usage);
-	createProject(templateDir, path.resolve(dir));
-	process.stdout.write(`Created a Protobase project in ${dir}. Next:\n\n${nextSteps(dir)}`);
+	const preset = await pickPreset(values.preset);
+	const { scripts } = createProject(path.join(templatesDir, preset), path.resolve(dir));
+	process.stdout.write(`Created a Protobase project in ${dir} from the ${preset} preset. Next:\n\n${nextSteps(dir, scripts ?? {})}`);
 };
-const run = (argv) => {
+const run = async (argv) => {
 	try {
-		create(argv);
+		await create(argv);
 	} catch (error) {
 		process.stderr.write(`error: ${error.message}\n`);
 		process.exitCode = 1;

package/dist/next-steps.js

@@ -1,10 +1,16 @@
 //#region src/next-steps.ts
-/** What to run in a new project, from `cwd`'s point of view, until its admin app serves. */
-const nextSteps = (dir) => [
+/**
+* What to run in a new project, from `cwd`'s point of view, until its admin app serves. `scripts` are those of the
+* project's package.json: a preset with a base seed loads it, and one with sample data offers it, before the first user,
+* who then owns the organizations the seeds wrote.
+*/
+const nextSteps = (dir, scripts) => [
 	`cd ${dir}`,
 	"bun install",
 	"cp .env.example .env   # then set DATABASE_URL and BETTER_AUTH_SECRET",
 	"bun run db:migrate",
+	..."db:seed:base" in scripts ? ["bun run db:seed:base"] : [],
+	..."db:seed" in scripts ? ["bun run db:seed --scale small   # optional: sample data, replacing the app tables"] : [],
 	"bun run protobase users create you@example.com --generate-password",
 	"bun run dev            # http://localhost:5173"
 ].map((line) => `  ${line}\n`).join("");

package/dist/presets.js

@@ -0,0 +1,17 @@
+import { readdirSync } from "node:fs";
+//#region src/presets.ts
+/** The preset a new project starts from when nobody picks one. */
+const defaultPreset = "scratch";
+/** The presets the build wrote to `templatesDir`, one folder each, the default first and the others by name. */
+const presetNames = (templatesDir) => {
+	const names = readdirSync(templatesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+	if (!names.includes("scratch")) throw new Error(`no ${defaultPreset} preset in ${templatesDir}`);
+	return [defaultPreset, ...names.filter((name) => name !== defaultPreset)];
+};
+/** `name` when it is one of `names`, else an error that lists them. */
+const checkPreset = (names, name) => {
+	if (!names.includes(name)) throw new Error(`unknown preset ${name}: pick one of ${names.join(", ")}`);
+	return name;
+};
+//#endregion
+export { checkPreset, defaultPreset, presetNames };

package/dist/templates/erp/.build-test-abf2a11f/protobase.config.ts

@@ -0,0 +1,6 @@
+import pg from 'pg'
+import postgres from 'postgres'
+import { jsonArrayFrom } from 'kysely/helpers/postgres'
+import { z } from 'zod'
+import * as config from './resources'
+export default { config, options: { found: [typeof pg.Pool, typeof postgres, typeof jsonArrayFrom, typeof z.object] } }

package/dist/templates/erp/.build-test-abf2a11f/resources.ts

@@ -0,0 +1,2 @@
+import { f, resource } from '@protobase/schema'
+export const things = resource('things').table('things').fields({ id: f.integer() }).primaryKey((r) => r.id)

package/dist/templates/erp/.build-test-b878b26f/config/index.ts

@@ -0,0 +1,2 @@
+export { things } from './things/data'
+export { thingsView } from './things/ui'

package/dist/templates/erp/.build-test-b878b26f/config/things/data.ts

@@ -0,0 +1,2 @@
+import { f, resource } from '@protobase/schema'
+export const things = resource('things').table('things').fields({ id: f.integer() }).primaryKey((r) => r.id)

package/dist/templates/erp/.build-test-b878b26f/config/things/ui.ts

@@ -0,0 +1,2 @@
+import { view } from '@protobase/schema'
+export const thingsView = view('things').names({ singular: 'Thing 😀', plural: 'Things' }).fields((r) => ({ id: r.id.prefix('€') }))

package/dist/templates/erp/.env.example

@@ -0,0 +1,14 @@
+# The ERP's own settings. The nearest .env wins, so this file, not the repository's, is the one `protobase dev`,
+# `protobase serve` and the db:* scripts read here. The Postgres container is the repository's (`bun run db:up`).
+DATABASE_URL=postgres://protobase:protobase@localhost:55432/protobase
+
+# Admin store (Better Auth users, sessions, signing keys): the `auth` schema of DATABASE_URL, created by `db:migrate`.
+# Public URL of the API, for cookies and as the issuer of the login tokens (use the https tunnel URL when tunnelling).
+BETTER_AUTH_URL=http://localhost:5173
+# Signs cookies and encrypts the token keys. Generate your own: openssl rand -base64 32
+BETTER_AUTH_SECRET=change-me-generate-with-openssl-rand-base64-32
+# Extra comma separated origins allowed to call the auth endpoints (a dev tunnel needs its exact host here, such as https://my-tunnel.trycloudflare.com).
+# TRUSTED_ORIGINS=
+# Mail for password reset and emailed sign-in and two-factor codes: the SMTP server (smtp:// with STARTTLS, or smtps://) and the sender. Without them those are off.
+# PROTOBASE_SMTP_URL=smtp://user:password@localhost:1025
+# PROTOBASE_MAIL_FROM=noreply@example.com

package/dist/templates/erp/AGENTS.md

@@ -0,0 +1,24 @@
+# Working on this app
+
+A Protobase app: each resource's data config in `config/<name>/data.ts` and its screens in `config/<name>/ui.ts`, all
+exported from `config/index.ts`, over a Postgres database. Reference: https://docs.protobase.net.
+
+## Database changes
+
+- Every schema change is a new migration file in `db/migrations/`, numbered after the last one (`009_returns.sql`).
+  Never edit or remove a migration that exists: it has already run on the live database.
+- Expand only, where possible: add tables, columns and indexes, and keep what the running app still reads. Rename or
+  drop only when asked to, once nothing uses it.
+- A new table gets `organization_id integer not null references core.organizations (id)` and `.tenant(...)`, like the
+  others: people work in one organization at a time, and see only its rows (`auth/auth.ts`).
+
+## Never touch
+
+- `auth/` and the `auth` schema: sign-in and accounts.
+- `.github/workflows/`.
+
+## Scripts
+
+The platform runs `db:migrate` (the auth schema's migrations included), `typecheck` and `test`, with their settings in
+the environment: keep them working. Run `typecheck` and `test` before you finish. `db:seed:base` loads the reference data and organization 1 (in the auth schema too),
+and `db:seed` the sample data, replacing everything in the app's tables.

package/dist/templates/erp/auth/auth.ts

@@ -0,0 +1,68 @@
+import { PostgresDialect } from 'kysely'
+import pg from 'pg'
+import { betterAuthAuthenticator, createAuth, handleDroppedConnections } from '@protobase/server'
+import { databaseUrl } from '../db/connection'
+
+const secret = process.env.BETTER_AUTH_SECRET
+if (!secret) throw new Error('BETTER_AUTH_SECRET is not set; generate one with `openssl rand -base64 32` and put it in .env')
+
+// One pool across hot reloads of this module
+const store = globalThis as { __erpAdminPool?: pg.Pool }
+store.__erpAdminPool ??= handleDroppedConnections(new pg.Pool({ connectionString: databaseUrl, max: 5 }))
+
+/** The admin store (Better Auth's users, sessions and signing keys) lives in this schema, next to the ERP's own schemas. */
+export const authSchema = 'auth'
+
+const pool = store.__erpAdminPool
+
+// The ERP's records name their organization by core.organizations' integer id, so a new organization takes the next
+// value of that table's sequence, and gets its row there with the ERP's own settings once it is made.
+const nextOrganizationId = async () => {
+  const { rows } = await pool.query<{ id: string }>("select nextval(pg_get_serial_sequence('core.organizations', 'id'))::text as id")
+  return rows[0]!.id
+}
+
+const addOrganizationRow = async ({ organization }: { organization: { id: string; name: string; slug: string } }) => {
+  await pool.query(
+    "insert into core.organizations (id, name, slug, country_code, currency_code) values ($1, $2, $3, 'NL', 'EUR') on conflict (id) do nothing",
+    [Number(organization.id), organization.name, organization.slug],
+  )
+}
+
+// Orders name their owner by core.users' integer id, so a new user takes the next value of that table's sequence; their
+// row there comes with their first membership (db/migrations/019_auth_users.sql).
+const nextUserId = async () => {
+  const { rows } = await pool.query<{ id: string }>("select nextval(pg_get_serial_sequence('core.users', 'id'))::text as id")
+  return rows[0]!.id
+}
+
+export const auth = createAuth({
+  database: { dialect: new PostgresDialect({ pool }), type: 'postgres', schemaName: authSchema, transaction: true },
+  baseURL: process.env.BETTER_AUTH_URL ?? 'http://localhost:5173',
+  secret,
+  // `admin` is the superuser, in every organization; the others are held per organization (or globally, by a few).
+  roles: {
+    admin: 'Superuser',
+    auditor: 'Auditor',
+    manager: { label: 'Manager', grants: ['sales', 'accountant', 'warehouse', 'editor'] },
+    sales: 'Sales',
+    accountant: 'Accountant',
+    warehouse: 'Warehouse',
+    editor: 'Editor',
+    integration: 'Integration',
+  },
+  generateUserId: nextUserId,
+  organizations: {
+    generateId: nextOrganizationId,
+    onCreated: addOrganizationRow,
+    hooks: {
+      afterUpdateOrganization: async ({ organization }) => {
+        if (organization) await pool.query('update core.organizations set name = $2, slug = $3 where id = $1', [Number(organization.id), organization.name, organization.slug])
+      },
+    },
+  },
+  trustedOrigins: process.env.TRUSTED_ORIGINS?.split(',').filter(Boolean),
+})
+
+/** The organization comes from the signed-in person's session: the one they work in. */
+export const authenticate = betterAuthAuthenticator({ auth })

package/dist/templates/erp/components/orders-per-day.tsx

@@ -0,0 +1,21 @@
+import { useSeries } from '@protobase/ui'
+
+/** Bars for orders per day; the custom component behind `<OrdersPerDay>` in config/overview/page.tsx. */
+export const OrdersPerDay = ({ days }: { days: 7 | 30 | 90 }) => {
+  const series = useSeries('orders', { field: 'created_at', range: `${days}d`, granularity: 'day' })
+  if (series.isPending) return <p className="text-muted-foreground">Loading</p>
+  if (series.error) return <p className="text-danger-text">Could not load the orders</p>
+  const points = series.data.points
+  const highest = Math.max(1, ...points.map((point) => point.count))
+  const total = points.reduce((sum, point) => sum + point.count, 0)
+  return (
+    <figure>
+      <div className="flex h-24 items-end gap-0.5" role="img" aria-label={`${total} orders in ${days} days`}>
+        {points.map((point) => (
+          <div key={point.bucket} title={`${point.bucket.slice(0, 10)}: ${point.count}`} className="flex-1 rounded-t-sm bg-primary/70" style={{ height: `${(point.count / highest) * 100}%` }} />
+        ))}
+      </div>
+      <figcaption className="mt-2 text-xs text-muted-foreground">{total.toLocaleString('en-IE')} orders</figcaption>
+    </figure>
+  )
+}

package/dist/templates/erp/config/bottom-bar.ts

@@ -0,0 +1,9 @@
+import { bottomBar } from '@protobase/schema'
+
+/** On phones, the warehouse floor's screens as tabs; "More" opens the rest. */
+export const warehouseBar = bottomBar({ label: 'Warehouse', roles: ['warehouse'] }, (m) => [
+  m.resource('stock_levels', { label: 'Stock' }),
+  m.resource('stock_moves', { label: 'Moves' }),
+  m.resource('orders', { label: 'Orders' }),
+  m.resource('locations', { label: 'Locations' }),
+])

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

@@ -0,0 +1,20 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** catalog.categories. Unique: (organization_id, slug) */
+export const categories = resource('categories')
+  .table('catalog.categories')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    parent_id: f.relation('categories').optional().filterable().sortable(),
+    name: f.text(),
+    slug: f.text().filterable().sortable(),
+    position: f.integer().default(0).sortable(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .position((r) => r.position, { within: (r) => r.parent_id })
+  .access(erpAccess('categories'))

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

@@ -0,0 +1,11 @@
+import { l, view } from '@protobase/schema'
+import type { categories } from './data'
+
+export const categoriesView = view<typeof categories>('categories')
+  .names({ singular: 'Category', plural: 'Categories' })
+  .list((r) => ({ columns: [r.name, r.slug, r.position] }))
+  .layout((r) => [
+    l.section('Category', [r.name, r.slug, r.parent_id, r.position]),
+    // Reordered by hand with its Reorder button, since each category's subcategories have an order of their own
+    l.related('Subcategories', { resource: 'categories', field: 'parent_id', sort: 'position', columns: ['name', 'slug'] }),
+  ])

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

@@ -0,0 +1,23 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** crm.companies */
+export const companies = resource('companies')
+  .table('crm.companies')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    name: f.text().filterable(),
+    country_code: f.relation('countries').filterable().sortable(),
+    city: f.text(),
+    vat_number: f.text().optional(),
+    email: f.text().optional(),
+    phone: f.text().optional(),
+    status: f.enum(['lead', 'active', 'dormant']).default('active').filterable().sortable(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .search((r) => [r.name, r.city])
+  .access(erpAccess('companies'))

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

@@ -0,0 +1,22 @@
+import { l, view } from '@protobase/schema'
+import type { companies } from './data'
+
+export const companiesView = view<typeof companies>('companies')
+  .title((r) => r.name)
+  .names({ singular: 'Company', plural: 'Companies' })
+  .fields((r) => ({
+    name: r.name.help('The registered name, as it should appear on invoices.'),
+    status: r.status.help('Leads have not ordered yet; dormant companies have not ordered in a year.').format('badge').valueLabels({ lead: 'Lead', active: 'Active', dormant: 'Dormant' }),
+    country_code: r.country_code.label('Country'),
+    vat_number: r.vat_number.label('VAT number').help('Required for invoices to other EU countries.').format('code'),
+    created_at: r.created_at.label('Created').format('absolute'),
+  }))
+  .list((r) => ({
+    columns: [r.name, r.city, r.country_code, r.status, r.email, r.phone, r.created_at],
+    search: [r.name],
+  }))
+  .filters((r, w) => [w.facets(r.status), w.facets(r.country_code)])
+  .layout((r) => [
+    l.section('Company', [r.name, r.status, r.city, r.country_code, r.vat_number], { help: 'Legal details used on quotes and invoices.' }),
+    l.section('Contact', [r.email, r.phone], { help: 'General contact details. People at the company are listed separately.' }),
+  ])

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

@@ -0,0 +1,16 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** crm.company_tags */
+export const companyTags = resource('company_tags')
+  .table('crm.company_tags')
+  .fields({
+    company_id: f.relation('companies').filterable().sortable(),
+    tag_id: f.relation('tags').filterable().sortable(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    added_by: f.relation('users').optional().filterable().sortable(),
+    added_at: f.timestamp().dbDefault(),
+  })
+  .primaryKey((r) => [r.company_id, r.tag_id])
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('company_tags'))

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

@@ -0,0 +1,7 @@
+import { view } from '@protobase/schema'
+import type { companyTags } from './data'
+
+export const companyTagsView = view<typeof companyTags>('company_tags')
+  .nav({ hidden: true })
+  .names({ singular: 'Company tag', plural: 'Company tags' })
+  .list((r) => ({ columns: [r.added_at, r.added_by] }))

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

@@ -0,0 +1,13 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** core.countries */
+export const countries = resource('countries')
+  .table('core.countries')
+  .fields({
+    code: f.text().filterable().sortable(),
+    name: f.text(),
+    eu_member: f.boolean().default(false),
+  })
+  .primaryKey((r) => r.code)
+  .access(erpAccess('countries'))

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

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { countries } from './data'
+
+export const countriesView = view<typeof countries>('countries')
+  .names({ singular: 'Country', plural: 'Countries' })
+  .list((r) => ({ columns: [r.name, r.eu_member] }))

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

@@ -0,0 +1,14 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** core.currencies */
+export const currencies = resource('currencies')
+  .table('core.currencies')
+  .fields({
+    code: f.text().filterable().sortable(),
+    name: f.text(),
+    symbol: f.text(),
+    decimals: f.integer().default(2),
+  })
+  .primaryKey((r) => r.code)
+  .access(erpAccess('currencies'))

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

@@ -0,0 +1,6 @@
+import { view } from '@protobase/schema'
+import type { currencies } from './data'
+
+export const currenciesView = view<typeof currencies>('currencies')
+  .names({ singular: 'Currency', plural: 'Currencies' })
+  .list((r) => ({ columns: [r.name, r.symbol, r.decimals] }))

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

@@ -0,0 +1,19 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess, roles } from '../roles'
+
+/** hr.EMP_MASTER */
+export const empMaster = resource('emp_master')
+  .table('hr.EMP_MASTER')
+  .fields({
+    emp_id: f.integer().column('EMP_ID').filterable().sortable(),
+    organization_id: f.relation('organizations').column('ORGANIZATION_ID').filterable().sortable(),
+    emp_name: f.text().column('EMP_NAME'),
+    dept_cd: f.text().column('DEPT_CD'),
+    hire_dt: f.date().column('HIRE_DT'),
+    sal_amt: f.decimal({ precision: 10, scale: 2 }).optional().column('SAL_AMT').access({ read: roles.is('admin') }),
+    mgr_id: f.relation('emp_master').optional().column('MGR_ID').filterable().sortable(),
+    active_flg: f.enum(['Y', 'N']).default('Y').column('ACTIVE_FLG'),
+  })
+  .primaryKey((r) => r.emp_id)
+  .tenant((r) => r.organization_id)
+  .access(erpAccess('emp_master'))

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

@@ -0,0 +1,7 @@
+import { view } from '@protobase/schema'
+import type { empMaster } from './data'
+
+export const empMasterView = view<typeof empMaster>('emp_master')
+  .names({ singular: 'Emp master', plural: 'Emp master' })
+  .fields((r) => ({ active_flg: r.active_flg.label('Active').valueLabels({ Y: 'Yes', N: 'No' }) }))
+  .list((r) => ({ columns: [r.emp_name, r.dept_cd, r.hire_dt, r.sal_amt, r.active_flg] }))

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

@@ -0,0 +1,42 @@
+export { categories } from './categories/data'
+export { categoriesView } from './categories/ui'
+export { products } from './products/data'
+export { productsView } from './products/ui'
+export { countries } from './countries/data'
+export { countriesView } from './countries/ui'
+export { currencies } from './currencies/data'
+export { currenciesView } from './currencies/ui'
+export { organizations } from './organizations/data'
+export { organizationsView } from './organizations/ui'
+export { users } from './users/data'
+export { usersView } from './users/ui'
+export { companies } from './companies/data'
+export { companiesView } from './companies/ui'
+export { companyTags } from './company_tags/data'
+export { companyTagsView } from './company_tags/ui'
+export { people } from './people/data'
+export { peopleView } from './people/ui'
+export { tags } from './tags/data'
+export { tagsView } from './tags/ui'
+export { empMaster } from './emp_master/data'
+export { empMasterView } from './emp_master/ui'
+export { locations } from './locations/data'
+export { locationsView } from './locations/ui'
+export { stockLevels } from './stock_levels/data'
+export { stockLevelsView } from './stock_levels/ui'
+export { stockMoves } from './stock_moves/data'
+export { stockMovesView } from './stock_moves/ui'
+export { warehouses } from './warehouses/data'
+export { warehousesView } from './warehouses/ui'
+export { invoiceLines } from './invoice_lines/data'
+export { invoiceLinesView } from './invoice_lines/ui'
+export { invoices } from './invoices/data'
+export { invoicesView } from './invoices/ui'
+export { orderLines } from './order_lines/data'
+export { orderLinesView } from './order_lines/ui'
+export { orders } from './orders/data'
+export { ordersView } from './orders/ui'
+export { accountMenu } from './user-menu'
+export { usersPage } from '@protobase/layout'
+export { warehouseBar } from './bottom-bar'
+export { salesOverview } from './overview/page'

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

@@ -0,0 +1,23 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** sales.invoice_lines. Unique: (invoice_id, position) */
+export const invoiceLines = resource('invoice_lines')
+  .table('sales.invoice_lines')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    invoice_id: f.relation('invoices').filterable().sortable(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    position: f.integer().sortable(),
+    product_id: f.relation('products').optional().filterable().sortable(),
+    description: f.text(),
+    quantity: f.integer(),
+    unit_price: f.decimal({ precision: 12, scale: 2 }),
+    line_total: f.decimal({ precision: 14, scale: 2 }).optional().readOnly(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .position((r) => r.position, { within: (r) => r.invoice_id })
+  .access(erpAccess('invoice_lines'))

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

@@ -0,0 +1,7 @@
+import { view } from '@protobase/schema'
+import type { invoiceLines } from './data'
+
+export const invoiceLinesView = view<typeof invoiceLines>('invoice_lines')
+  .nav({ hidden: true })
+  .names({ singular: 'Invoice line', plural: 'Invoice lines' })
+  .list((r) => ({ columns: [r.position, r.quantity, r.unit_price, r.line_total] }))

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

@@ -0,0 +1,26 @@
+import { f, resource } from '@protobase/schema'
+import { erpAccess } from '../roles'
+
+/** sales.invoices. Unique: (organization_id, number) */
+export const invoices = resource('invoices')
+  .table('sales.invoices')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    number: f.text().filterable().sortable(),
+    order_id: f.relation('orders').optional().filterable().sortable(),
+    company_id: f.relation('companies').filterable().sortable(),
+    status: f.enum(['draft', 'sent', 'paid', 'overdue']).default('draft').filterable().sortable(),
+    issued_at: f.date().filterable().sortable(),
+    due_at: f.date(),
+    vat_rate: f.decimal({ precision: 4, scale: 2 }).default('21'),
+    subtotal: f.decimal({ precision: 14, scale: 2 }).readOnly().default('0'),
+    vat: f.decimal({ precision: 14, scale: 2 }).readOnly().default('0'),
+    total: f.decimal({ precision: 14, scale: 2 }).readOnly().default('0'),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .search((r) => [r.number])
+  .access(erpAccess('invoices'))

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

@@ -0,0 +1,38 @@
+import { l, view } from '@protobase/schema'
+import type { invoices } from './data'
+
+export const invoicesView = view<typeof invoices>('invoices')
+  .title((r) => r.number)
+  .names({ singular: 'Invoice', plural: 'Invoices' })
+  .nav({ recent: { status: 'status', tones: { draft: 'neutral', sent: 'info', overdue: 'danger' }, filter: 'status != "paid"', orderBy: 'issued_at desc', limit: 3 } })
+  .fields((r) => ({
+    number: r.number.help('Assigned when the invoice is created.').format('code'),
+    company_id: r.company_id.label('Customer').help('The company that receives the invoice.'),
+    order_id: r.order_id.label('Order').help('The sales order this invoice bills, if any.'),
+    status: r.status.help('Sent invoices are emailed to the customer; overdue ones trigger reminders.').format('badge').valueLabels({ draft: 'Draft', sent: 'Sent', paid: 'Paid', overdue: 'Overdue' }),
+    issued_at: r.issued_at.label('Issue date').help('The date printed on the invoice.'),
+    due_at: r.due_at.label('Due date').help('Usually the issue date plus the payment terms.'),
+    vat_rate: r.vat_rate.label('VAT rate').help('Percentage added to the subtotal.').format('percent'),
+    subtotal: r.subtotal.prefix('€').decimals(2),
+    vat: r.vat.label('VAT').prefix('€').decimals(2),
+    total: r.total.help('Subtotal plus VAT.').prefix('€').decimals(2),
+  }))
+  .list((r) => ({
+    columns: [r.number, r.company_id, r.status, r.issued_at, r.due_at, r.total],
+    search: [r.number],
+  }))
+  .filters((r, w) => [w.facets(r.status), w.dateRange(r.issued_at, { presets: ['30d', '90d', 'quarter', 'year'] })])
+  .layout((r) => [
+    l.section('Billing details', [r.company_id, r.order_id, r.status, r.issued_at, r.due_at], {
+      help: 'Who is being billed and when payment is due. Changes are saved when you press Save.',
+    }),
+    l.section('Totals', [r.vat_rate, r.subtotal, r.vat, r.total], {
+      help: 'Calculated from the invoice lines. The VAT rate applies to the whole invoice.',
+    }),
+    l.sidebar([r.status, r.total]),
+  ])
+  .saveFeedback('button')
+  .actions((a) => [
+    a.action('send', { label: 'Send to customer', icon: 'send', confirm: 'Email the PDF to the customer and mark the invoice as sent?' }),
+    a.update('recordPayment', { label: 'Record payment', icon: 'wallet', set: { status: 'paid' } }),
+  ])