@kernhq/module-inventory 0.1.0

package/src/module.test.ts

@@ -0,0 +1,79 @@
+/**
+ * This module's guard rails. Keep this file: it is what stops the contract and the router drifting.
+ *
+ * It needs no database and no running service: it walks the contract and the router as data and
+ * checks the two things that are easy to forget and impossible for `tsc` to see.
+ *
+ *   1. every procedure the contract promises is actually implemented — a contract entry with no
+ *      router entry type-checks perfectly and 404s at runtime;
+ *   2. every implemented procedure is behind `workspaceScoped()` *and* a `requires()` — a procedure
+ *      that forgets the second one is readable by any member of any workspace with the module on.
+ *
+ * Add your module's real tests next to it; this one keeps working as the contract grows.
+ */
+import type { Kernel } from '@kernhq/kernel'
+import { describe, expect, it } from 'vitest'
+import { inventoryContract, inventoryEvents, inventoryPermissions, MODULE_ID } from './contract.js'
+import { implement_ } from './server/_impl.js'
+import { inventoryModule } from './server/index.js'
+
+/** An oRPC procedure (contract or implementation) carries `~orpc`; a router group does not. */
+interface Leaf {
+  '~orpc': {
+    route?: { method?: string; path?: string }
+    middlewares?: unknown[]
+  }
+}
+const isLeaf = (node: unknown): node is Leaf => typeof node === 'object' && node !== null && '~orpc' in node
+
+/** `{ widgets: { list, create } }` → `{ 'widgets.list': leaf, 'widgets.create': leaf }` */
+function leaves(node: unknown, path: string[] = []): Record<string, Leaf> {
+  if (isLeaf(node)) return { [path.join('.')]: node }
+  if (typeof node !== 'object' || node === null) return {}
+  return Object.entries(node).reduce<Record<string, Leaf>>(
+    (acc, [key, value]) => Object.assign(acc, leaves(value, [...path, key])),
+    {},
+  )
+}
+
+// The router is only inspected, never called, so it needs no real kernel behind it.
+const declared = leaves(inventoryContract)
+const implemented = leaves(implement_({} as Kernel))
+
+describe('the contract and the router agree', () => {
+  it('implements every declared procedure, and nothing that was never declared', () => {
+    expect(Object.keys(implemented).sort()).toEqual(Object.keys(declared).sort())
+  })
+
+  it('keeps the REST route the contract published', () => {
+    for (const [name, leaf] of Object.entries(implemented)) {
+      const contractRoute = declared[name]?.['~orpc'].route
+      expect(leaf['~orpc'].route?.method, `${name} method`).toBe(contractRoute?.method)
+      expect(leaf['~orpc'].route?.path, `${name} path`).toBe(contractRoute?.path)
+    }
+  })
+})
+
+describe('every procedure is authorised', () => {
+  it('carries both the workspace/module gate and a permission check', () => {
+    for (const [name, leaf] of Object.entries(implemented)) {
+      // `workspaceScoped(MODULE_ID)` + `requires('<permission>')`
+      expect(leaf['~orpc'].middlewares?.length ?? 0, `${name} middlewares`).toBeGreaterThanOrEqual(2)
+    }
+  })
+})
+
+describe('the module declares what it uses', () => {
+  it('names its permissions and events under its own module id', () => {
+    for (const p of inventoryPermissions) expect(p.key.startsWith(`${MODULE_ID}.`), p.key).toBe(true)
+    for (const e of Object.values(inventoryEvents))
+      expect(e.name.startsWith(`${MODULE_ID}.`), e.name).toBe(true)
+  })
+
+  it('registers those permissions and events on the server module', () => {
+    expect(inventoryModule.definition.id).toBe(MODULE_ID)
+    expect(inventoryModule.definition.permissions).toBe(inventoryPermissions)
+    expect(inventoryModule.definition.events).toBe(inventoryEvents)
+    expect(inventoryModule.router, 'a module with a contract has to mount a router').toBeTypeOf('function')
+  })
+})

package/src/server/_impl.ts

@@ -0,0 +1,275 @@
+import {
+  defineModule,
+  defineServerModule,
+  KernError,
+  type Kernel,
+  packageVersion,
+  type RequestContext,
+  requires,
+  type Tx,
+  uuidv7,
+  workspaceScoped,
+} from '@kernhq/kernel'
+import { implement } from '@orpc/server'
+import { and, desc, eq, ilike, or, sql } from 'drizzle-orm'
+import { type Asset as AssetModel, inventoryContract, inventoryEvents, MODULE_ID } from '../contract.js'
+import { assetHistory, assets, counters } from './schema.js'
+
+/**
+ * The router, kept apart from `index.ts` so `module.test.ts` can walk it without booting a kernel.
+ *
+ * Two middlewares on every procedure, and the test fails if either is missing:
+ * `workspaceScoped` (a real membership, and the module switched on for that workspace) and
+ * `requires` (the permission this particular call needs).
+ */
+export { defineModule, defineServerModule, packageVersion }
+
+const os = implement(inventoryContract).$context<RequestContext>()
+
+/** The wire shape: drizzle gives Date objects for timestamps, the contract promises ISO strings. */
+function toAsset(row: typeof assets.$inferSelect): AssetModel {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId as AssetModel['workspaceId'],
+    code: row.code,
+    name: row.name,
+    description: row.description,
+    categoryId: row.categoryId,
+    status: row.status,
+    custodianUserId: row.custodianUserId,
+    custodySince: row.custodySince?.toISOString() ?? null,
+    serialNumber: row.serialNumber,
+    location: row.location,
+    purchasedOn: row.purchasedOn ?? null,
+    purchasedFrom: row.purchasedFrom,
+    priceMinor: row.priceMinor,
+    currency: row.currency,
+    warrantyUntil: row.warrantyUntil ?? null,
+    photoFileId: row.photoFileId,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+    archivedAt: row.archivedAt?.toISOString() ?? null,
+  }
+}
+
+/**
+ * The next asset tag for a workspace. One narrow row per workspace and key, incremented under the
+ * insert's conflict lock — two concurrent creates each read the value their own update returned, so
+ * codes stay unique without a retry loop. `INV-0042`, because people say asset tags out loud.
+ */
+async function nextCode(
+  tx: Parameters<Parameters<Kernel['database']['withWorkspace']>[1]>[0],
+  workspaceId: string,
+) {
+  const [row] = await tx
+    .insert(counters)
+    .values({ workspaceId, key: 'asset_code', value: 1 })
+    .onConflictDoUpdate({
+      target: [counters.workspaceId, counters.key],
+      set: { value: sql`${counters.value} + 1` },
+    })
+    .returning()
+  return `INV-${String(row!.value).padStart(4, '0')}`
+}
+
+export function implement_(kernel: Kernel) {
+  const scoped = os.use(workspaceScoped(MODULE_ID))
+
+  const changed = (workspaceId: string, id: string, op: 'created' | 'updated' | 'deleted') =>
+    kernel.realtime.change(workspaceId, { module: MODULE_ID, entity: 'asset', id, op })
+
+  async function record(
+    tx: Tx,
+    input: { workspaceId: string },
+    assetId: string,
+    actorId: string | null | undefined,
+    action: string,
+    changes: { field: string; from: unknown; to: unknown }[] = [],
+    data?: Record<string, unknown>,
+  ) {
+    await tx.insert(assetHistory).values({
+      id: uuidv7(),
+      workspaceId: input.workspaceId,
+      assetId,
+      actorId: actorId ?? null,
+      action,
+      changes,
+      data: data ?? null,
+    })
+  }
+
+  return os.router({
+    assets: {
+      list: scoped.assets.list.use(requires('inventory.asset.view')).handler(({ input }) =>
+        kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+          const filters = [eq(assets.workspaceId, input.workspaceId)]
+          if (input.q) {
+            // A code is something somebody reads off a sticker; matching name, code and serial
+            // loosely matters more than word-splitting here. Full-text arrives with the core indexer.
+            filters.push(
+              or(
+                ilike(assets.name, `%${input.q}%`),
+                ilike(assets.code, `%${input.q}%`),
+                ilike(sql`coalesce(${assets.serialNumber}, '')`, `%${input.q}%`),
+              )!,
+            )
+          }
+          if (input.categoryId) filters.push(eq(assets.categoryId, input.categoryId))
+          if (input.status) filters.push(eq(assets.status, input.status))
+
+          const order =
+            input.sort === 'name' ? assets.name : input.sort === 'code' ? assets.code : desc(assets.createdAt)
+
+          const rows = await tx
+            .select()
+            .from(assets)
+            .where(and(...filters))
+            .orderBy(order)
+            .limit(input.limit)
+          return { items: rows.map(toAsset), nextCursor: null }
+        }),
+      ),
+
+      get: scoped.assets.get.use(requires('inventory.asset.view')).handler(({ input }) =>
+        kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+          const [row] = await tx
+            .select()
+            .from(assets)
+            .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
+          if (!row) throw KernError.notFound('Asset')
+          return toAsset(row)
+        }),
+      ),
+
+      create: scoped.assets.create
+        .use(requires('inventory.asset.manage'))
+        .handler(async ({ input, context }) => {
+          const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+            const [r] = await tx
+              .insert(assets)
+              .values({
+                id: uuidv7(),
+                workspaceId: input.workspaceId,
+                code: await nextCode(tx, input.workspaceId),
+                name: input.name,
+                description: input.description,
+                categoryId: input.categoryId ?? null,
+                serialNumber: input.serialNumber ?? null,
+                location: input.location ?? null,
+                purchasedFrom: input.purchasedFrom ?? null,
+                purchasedOn: input.purchasedOn ?? null,
+                warrantyUntil: input.warrantyUntil ?? null,
+                priceMinor: input.priceMinor ?? null,
+                currency: input.currency ?? null,
+              })
+              .returning()
+            await record(tx, input, r!.id, context.principal.userId, 'created')
+            return r!
+          })
+
+          // Both, every time. The event is for anything that reacts later; the realtime change is
+          // what redraws a screen somebody is looking at now. A mutation that does neither leaves
+          // the rest of the product believing the old answer.
+          await kernel.emit(
+            inventoryEvents.assetCreated,
+            { assetId: row.id, workspaceId: input.workspaceId },
+            { workspaceId: input.workspaceId, actorId: context.principal.userId },
+          )
+          await changed(input.workspaceId, row.id, 'created')
+
+          return toAsset(row)
+        }),
+
+      update: scoped.assets.update
+        .use(requires('inventory.asset.manage'))
+        .handler(async ({ input, context }) => {
+          const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+            const [prev] = await tx
+              .select()
+              .from(assets)
+              .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
+              .for('update')
+            if (!prev) throw KernError.notFound('Asset')
+
+            const patch = {
+              name: input.name ?? prev.name,
+              description: input.description ?? prev.description,
+              categoryId: input.categoryId !== undefined ? (input.categoryId ?? null) : prev.categoryId,
+              serialNumber:
+                input.serialNumber !== undefined ? (input.serialNumber ?? null) : prev.serialNumber,
+              location: input.location !== undefined ? (input.location ?? null) : prev.location,
+              purchasedFrom:
+                input.purchasedFrom !== undefined ? (input.purchasedFrom ?? null) : prev.purchasedFrom,
+              purchasedOn: input.purchasedOn !== undefined ? (input.purchasedOn ?? null) : prev.purchasedOn,
+              warrantyUntil:
+                input.warrantyUntil !== undefined ? (input.warrantyUntil ?? null) : prev.warrantyUntil,
+              priceMinor: input.priceMinor !== undefined ? (input.priceMinor ?? null) : prev.priceMinor,
+              currency: input.currency !== undefined ? (input.currency ?? null) : prev.currency,
+              updatedAt: new Date(),
+            }
+
+            const [r] = await tx.update(assets).set(patch).where(eq(assets.id, input.assetId)).returning()
+
+            // Field-level diffs are the timeline — write only what actually moved.
+            const fields = [
+              'name',
+              'description',
+              'categoryId',
+              'serialNumber',
+              'location',
+              'purchasedFrom',
+              'purchasedOn',
+              'warrantyUntil',
+              'priceMinor',
+              'currency',
+            ] as const
+            const iso = (v: unknown) => (v instanceof Date ? v.toISOString() : v) ?? null
+            const changes = fields
+              .filter((f) => iso(patch[f]) !== iso(prev[f]))
+              .map((f) => ({ field: f, from: iso(prev[f]), to: iso(patch[f]) }))
+            if (changes.length > 0)
+              await record(tx, input, input.assetId, context.principal.userId, 'updated', changes)
+
+            return r!
+          })
+
+          await kernel.emit(
+            inventoryEvents.assetUpdated,
+            { assetId: row.id, workspaceId: input.workspaceId },
+            { workspaceId: input.workspaceId, actorId: context.principal.userId },
+          )
+          await changed(input.workspaceId, row.id, 'updated')
+          return toAsset(row)
+        }),
+
+      archive: scoped.assets.archive
+        .use(requires('inventory.asset.manage'))
+        .handler(async ({ input, context }) => {
+          const row = await kernel.database.withWorkspace(input.workspaceId, async (tx) => {
+            const [r] = await tx
+              .update(assets)
+              .set({ archivedAt: input.archived ? new Date() : null, updatedAt: new Date() })
+              .where(and(eq(assets.workspaceId, input.workspaceId), eq(assets.id, input.assetId)))
+              .returning()
+            if (!r) throw KernError.notFound('Asset')
+            await record(
+              tx,
+              input,
+              input.assetId,
+              context.principal.userId,
+              input.archived ? 'retired' : 'restored',
+            )
+            return r
+          })
+
+          await kernel.emit(
+            inventoryEvents.assetArchived,
+            { assetId: row.id, workspaceId: input.workspaceId },
+            { workspaceId: input.workspaceId, actorId: context.principal.userId },
+          )
+          await changed(input.workspaceId, row.id, 'updated')
+          return toAsset(row)
+        }),
+    },
+  })
+}

package/src/server/index.ts

@@ -0,0 +1,33 @@
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { inventoryContract, inventoryEvents, inventoryPermissions, MODULE_ID } from '../contract.js'
+import { defineModule, defineServerModule, implement_, packageVersion } from './_impl.js'
+import { schema } from './schema.js'
+
+export const inventoryModule = defineServerModule({
+  definition: defineModule({
+    id: MODULE_ID,
+    name: 'Inventory',
+    version: packageVersion(import.meta.url),
+    description:
+      'The asset register: what the company owns, who holds each item, and everything that happened to it',
+    icon: 'briefcase',
+    permissions: inventoryPermissions,
+    events: inventoryEvents,
+  }),
+  /** Attached so the developer panel can check the router against what was promised. */
+  contract: inventoryContract,
+  schema,
+  migrationsFolder: join(dirname(fileURLToPath(import.meta.url)), '../../migrations'),
+  router: implement_,
+  /**
+   * What this module reacts to. The pattern may be an exact name, `module.*`, or `*`; handlers are
+   * durable consumers in production, so one that throws is retried rather than lost.
+   */
+  subscriptions: {
+    'core.workspace.created': async (event, kernel) => {
+      kernel.log.info({ module: MODULE_ID, event: event.name }, 'a workspace was created')
+    },
+  },
+})
+export default inventoryModule

package/src/server/schema.ts

@@ -0,0 +1,228 @@
+import { moduleSchema } from '@kernhq/kernel'
+import { sql } from 'drizzle-orm'
+import {
+  boolean,
+  char,
+  date,
+  index,
+  integer,
+  jsonb,
+  pgEnum,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid,
+} from 'drizzle-orm/pg-core'
+
+/**
+ * This module's tables, in its own Postgres schema.
+ *
+ * Two rules, neither optional:
+ *
+ * - every tenant table carries `workspace_id` and an index that starts with it;
+ * - every tenant table gets a row-level security policy, hand-written in the migration, because
+ *   drizzle-kit does not generate one. RLS is the last line — the API check is the first, and
+ *   somebody will eventually write a query that skips it.
+ */
+export const schema = moduleSchema('inventory')
+
+/** Local column factories, so the conventions stay in one place. */
+const id = () => uuid('id').primaryKey().default(sql`uuidv7()`)
+const ws = () => uuid('workspace_id').notNull()
+const ts = (name: string) => timestamp(name, { withTimezone: true, mode: 'date' })
+const created = () => ts('created_at').notNull().defaultNow()
+const updated = () => ts('updated_at').notNull().defaultNow()
+
+/**
+ * Asset lifecycle. Stored rather than derived because every list filter asks for it; every
+ * transition is written inside the same transaction as the row it derives from.
+ */
+export const assetStatus = pgEnum('asset_status', ['in_stock', 'assigned', 'under_repair', 'retired'])
+
+export const counters = schema.table(
+  'counters',
+  /** Per-workspace sequence sources (`asset_code`). Narrow on purpose: one row per key. */
+  {
+    workspaceId: ws().primaryKey(),
+    key: text('key').primaryKey(),
+    value: integer('value').notNull(),
+  },
+)
+
+export const categories = schema.table(
+  'categories',
+  {
+    id: id(),
+    workspaceId: ws(),
+    name: text('name').notNull(),
+    order: integer('order').notNull().default(0),
+    createdAt: created(),
+    updatedAt: updated(),
+  },
+  (t) => [
+    uniqueIndex('inventory_categories_ws_name_uq').on(t.workspaceId, t.name),
+    index('inventory_categories_ws_idx').on(t.workspaceId, t.order),
+  ],
+)
+
+export const assets = schema.table(
+  'assets',
+  {
+    id: id(),
+    workspaceId: ws(),
+    code: text('code').notNull(),
+    name: text('name').notNull(),
+    description: text('description').notNull().default(''),
+    categoryId: uuid('category_id'),
+    status: assetStatus('status').notNull().default('in_stock'),
+    /** Denormalized from `custody_periods`, which stays authoritative for history. */
+    custodianUserId: uuid('custodian_user_id'),
+    custodySince: ts('custody_since'),
+    serialNumber: text('serial_number'),
+    location: text('location'),
+    purchasedOn: date('purchased_on'),
+    purchasedFrom: text('purchased_from'),
+    priceMinor: integer('price_minor'),
+    currency: char('currency', { length: 3 }),
+    warrantyUntil: date('warranty_until'),
+    photoFileId: uuid('photo_file_id'),
+    createdAt: created(),
+    updatedAt: updated(),
+    archivedAt: ts('archived_at'),
+  },
+  (t) => [
+    uniqueIndex('inventory_assets_ws_code_uq').on(t.workspaceId, t.code),
+    index('inventory_assets_ws_created_idx').on(t.workspaceId, t.createdAt),
+    index('inventory_assets_ws_status_idx').on(t.workspaceId, t.status),
+    index('inventory_assets_ws_category_idx').on(t.workspaceId, t.categoryId),
+    // The "what leaves warranty this month" scan, before a job makes it a widget's cheap query.
+    index('inventory_assets_ws_warranty_idx')
+      .on(t.workspaceId, t.warrantyUntil)
+      .where(sql`warranty_until is not null`),
+  ],
+)
+
+/**
+ * Workspace-defined extra fields, copied from tracker's `field_defs` (which cannot be shared:
+ * cross-schema joins are what the module boundary exists to prevent). The `key` **is** the key a
+ * value lives under in `assets.custom`, hence unique per workspace whatever the category scope.
+ */
+export const fieldDefs = schema.table(
+  'field_defs',
+  {
+    id: id(),
+    workspaceId: ws(),
+    categoryId: uuid('category_id'),
+    key: text('key').notNull(),
+    name: text('name').notNull(),
+    description: text('description'),
+    type: text('type').notNull(), // text | number | date | select | multiselect | checkbox | url
+    options: jsonb('options').$type<string[]>(),
+    defaultValue: jsonb('default_value'),
+    required: boolean('required').notNull().default(false),
+    searchable: boolean('searchable').notNull().default(false),
+    showInList: boolean('show_in_list').notNull().default(false),
+    order: integer('order').notNull().default(0),
+    archivedAt: ts('archived_at'),
+    createdAt: created(),
+    updatedAt: updated(),
+  },
+  (t) => [
+    uniqueIndex('inventory_field_defs_ws_key_uq').on(t.workspaceId, t.key),
+    index('inventory_field_defs_ws_idx').on(t.workspaceId, t.order),
+  ],
+)
+
+/**
+ * Custody over time. Never updated in place — a change closes the open row and inserts a new one,
+ * the way HR keeps employments. The exclusion constraint (hand-written migration) makes two open
+ * periods for one asset impossible at the database level, not merely unlikely in the service.
+ */
+export const custodyPeriods = schema.table(
+  'custody_periods',
+  {
+    id: id(),
+    workspaceId: ws(),
+    assetId: uuid('asset_id').notNull(),
+    userId: uuid('user_id').notNull(),
+    note: text('note'),
+    effectiveFrom: ts('effective_from').notNull().defaultNow(),
+    effectiveTo: ts('effective_to'),
+    createdBy: uuid('created_by'),
+    createdAt: created(),
+  },
+  (t) => [index('inventory_custody_ws_asset_idx').on(t.workspaceId, t.assetId, t.effectiveFrom)],
+)
+
+/**
+ * Append-only. What changed, when, by whom — the timeline an asset page renders and the answer to
+ * "who had this laptop before me". Written inside the caller's transaction; nothing edits or
+ * deletes rows here, ever.
+ */
+export const assetHistory = schema.table(
+  'asset_history',
+  {
+    id: id(),
+    workspaceId: ws(),
+    assetId: uuid('asset_id').notNull(),
+    actorId: uuid('actor_id'),
+    action: text('action').notNull(), // created | updated | transferred | returned | repair_logged | repair_completed | attachment_added | retired | restored
+    changes: jsonb('changes').$type<{ field: string; from: unknown; to: unknown }[]>(),
+    data: jsonb('data'),
+    occurredAt: created(),
+  },
+  (t) => [index('inventory_asset_history_asset_idx').on(t.workspaceId, t.assetId, t.occurredAt)],
+)
+
+export const repairs = schema.table(
+  'repairs',
+  {
+    id: id(),
+    workspaceId: ws(),
+    assetId: uuid('asset_id').notNull(),
+    summary: text('summary').notNull(),
+    detail: text('detail'),
+    vendor: text('vendor'),
+    costMinor: integer('cost_minor'),
+    currency: char('currency', { length: 3 }),
+    sentOn: date('sent_on').notNull(),
+    /** Null while the item is still away — also how `under_repair` is derived. */
+    returnedOn: date('returned_on'),
+    createdBy: uuid('created_by'),
+    createdAt: created(),
+    updatedAt: updated(),
+  },
+  (t) => [index('inventory_repairs_ws_asset_idx').on(t.workspaceId, t.assetId, t.sentOn)],
+)
+
+/** Bytes live in core object storage via `uploadFile`; this only records that an asset has one. */
+export const attachments = schema.table(
+  'attachments',
+  {
+    id: id(),
+    workspaceId: ws(),
+    assetId: uuid('asset_id').notNull(),
+    repairId: uuid('repair_id'),
+    fileId: uuid('file_id').notNull(),
+    name: text('name').notNull(),
+    mimeType: text('mime_type'),
+    size: integer('size'),
+    uploadedBy: uuid('uploaded_by'),
+    createdAt: created(),
+  },
+  (t) => [
+    uniqueIndex('inventory_attachments_asset_file_uq').on(t.assetId, t.fileId),
+    index('inventory_attachments_ws_asset_idx').on(t.workspaceId, t.assetId, t.createdAt),
+  ],
+)
+
+/** Every tenant table, so the RLS migration can be checked against one list rather than memory. */
+export const TENANT_TABLES = [
+  'categories',
+  'assets',
+  'field_defs',
+  'custody_periods',
+  'asset_history',
+  'repairs',
+  'attachments',
+] as const

package/tsconfig.client.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"]
+  },
+  "include": ["src/client/**/*.ts", "src/client/**/*.svelte", "src/contract.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "types": ["node"]
+  },
+  "include": ["src/contract.ts", "src/server"],
+  "exclude": ["src/**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from 'vitest/config'
+
+// `passWithNoTests` so a copy of this package that has not written its first test yet still reports a
+// green `pnpm test` for the whole workspace instead of failing on "no test files found".
+export default defineConfig({ test: { include: ['src/**/*.test.ts'], passWithNoTests: true } })