@rangka/core 0.1.0 → 0.1.2

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@rangka/core",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -17,7 +21,7 @@
     "kysely": "^0.29.2",
     "pg": "^8.13.1",
     "qs": "^6.15.2",
-    "@rangka/shared": "0.1.0"
+    "@rangka/shared": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/.claude/skills/extend-core/SKILL.md

@@ -1,133 +0,0 @@
----
-name: extend-core
-description: Extending or modifying @rangka/core internals (registries, handlers, boot, context). Use when contributing to the framework itself.
----
-
-## Before you write any code
-
-You are modifying framework internals. App developers depend on the public API staying stable. Every change must preserve existing behavior unless intentionally breaking (with migration path).
-
-1. Identify what you are changing:
-   - A registry (SchemaRegistry, HookRegistry, PermissionRegistry, etc.)
-   - The boot sequence (`src/boot/index.ts`)
-   - The route generator (`src/api/route-generator.ts`)
-   - The hook pipeline (`src/hooks/executor.ts`, `src/hooks/middleware.ts`)
-   - FrameworkContext (`@rangka/shared` types/context.ts + `src/hooks/context.ts`)
-   - Model access layer (`src/model-api/`)
-
-2. Read the public API surface that consumers use:
-   - `FrameworkContext` in `@rangka/shared/src/types/context.ts` — hooks, services, and jobs receive this
-   - `ModelAccessInterface` / `ModelQueryInterface` in the same file — the query API app devs call
-   - `defineHooks`, `defineService`, `defineJob` in `@rangka/shared/src/define.ts` — app definition API
-   - `BootPayload` in `@rangka/shared/src/types/boot.ts` — what the client receives at startup
-
-3. Search for all consumers before modifying:
-   ```bash
-   grep -r "ctx.models" packages/core/src/
-   grep -r "FrameworkContext" packages/
-   grep -r "SchemaRegistry" packages/core/src/
-   ```
-
-## Extending a registry
-
-Registries are singleton objects created during boot. They hold runtime state.
-
-Pattern for adding a method:
-
-1. Add the method to the registry class (e.g., `src/schema/registry.ts`)
-2. If the method is exposed to app devs via FrameworkContext, update the interface in `@rangka/shared`
-3. Verify all existing tests still pass
-4. Add a test for the new method
-
-Pattern for adding a new registry:
-
-1. Create in its own file under the relevant domain (e.g., `src/notifications/registry.ts`)
-2. Instantiate in `src/boot/index.ts` during the boot sequence
-3. Wire into `FrameworkContext` if app devs need access
-4. Update `@rangka/shared` types if the interface is public
-
-## Modifying FrameworkContext
-
-This is the most sensitive change. Every hook, service, and job receives this object.
-
-Adding a new field:
-
-1. Add the field to `FrameworkContext` in `@rangka/shared/src/types/context.ts`
-2. Make it optional if not all consumers need it (backward compatible)
-3. Build it in `src/hooks/context.ts` (`createHookContext`) AND `src/context.ts` (`createFrameworkContext`)
-4. Rebuild shared first, then core: `pnpm --filter @rangka/shared build && pnpm --filter @rangka/core build`
-5. Verify no type errors across the monorepo: `pnpm build`
-
-Modifying an existing field's type:
-
-- Breaking change. Grep all usages across the monorepo. Update every consumer in the same PR.
-
-## Modifying the hook pipeline
-
-The hook pipeline is in `src/hooks/executor.ts` and `src/hooks/middleware.ts`.
-
-- `executor.ts` — runs hook chains (validate → before → after) in sequence
-- `middleware.ts` — Fastify request handlers that orchestrate the full CRUD + hooks flow
-
-Rules:
-
-- Hook phases are fixed: validate, beforeCreate, beforeUpdate, beforeSave, afterCreate, afterUpdate, afterSave, beforeDelete, afterDelete
-- Do NOT add new phases without updating `HookLifecycle` type in `src/hooks/types.ts` AND the executor
-- The middleware functions (`withHooksCreate`, `withHooksUpdate`, `withHooksDelete`) are the authoritative CRUD handlers. Never create a parallel CRUD path.
-
-## Modifying the route generator
-
-`src/api/route-generator.ts` auto-generates REST routes for all models.
-
-- It uses `withHooksCreate/Update/Delete` from `src/hooks/middleware.ts` for mutations
-- It uses `listHandler/getHandler` from `src/api/handlers.ts` for reads
-- Auth/scope/permission guards are applied as Fastify preHandler hooks
-
-To add a new capability to all model routes (e.g., new query parameter, new response field):
-
-1. Modify the relevant handler in `src/api/handlers.ts`
-2. Update OpenAPI schema generation if applicable (`src/api/openapi-schema.ts`)
-3. Test with integration tests
-
-To add a non-model route (e.g., `/api/meta/...`):
-
-- Add it inside `generateRoutes()` alongside the existing meta/session routes
-
-## Modifying model-api
-
-The model access layer (`src/model-api/`) is the query engine.
-
-- `query-builder.ts` — ModelQueryBuilder (fluent API for filtering/sorting/pagination)
-- `filter-translator.ts` — converts API filter syntax to Kysely where clauses
-- `filter-applier.ts` — applies filter conditions to a query
-- `scope-enforcer.ts` — enforces tenant/scope/field-level permissions
-- `include-resolver.ts` — resolves relationship includes
-- `field-access.ts` — strips hidden fields, enforces readOnly
-
-Rules:
-
-- New filter operators go in `filter-translator.ts`
-- New query capabilities go as methods on `ModelQueryBuilder`
-- Never bypass scope enforcement — if you need unscoped access, use `.unscoped()` explicitly
-- The `ModelAccessInterface` in `@rangka/shared` is the public contract. Adding a method there is fine (additive). Changing signatures is breaking.
-
-## Anti-patterns
-
-| Anti-pattern                                                       | Correct approach                                   |
-| ------------------------------------------------------------------ | -------------------------------------------------- |
-| New CRUD handler that skips hooks                                  | Use `withHooksCreate/Update/Delete`                |
-| Custom filter logic in a route handler                             | Add to `filter-translator.ts`                      |
-| Direct Kysely queries for model CRUD in handlers                   | Use model-api through the existing handler pattern |
-| New singleton that duplicates a registry's purpose                 | Extend the existing registry                       |
-| Modifying `FrameworkContext` in core without updating shared types | Always update `@rangka/shared` first               |
-| Adding a field to `BootPayload` without updating client consumer   | Check `packages/client/src/boot/`                  |
-
-## Checklist
-
-- [ ] Identified all consumers of the changed API (grep across monorepo)
-- [ ] Public interfaces in `@rangka/shared` updated if needed
-- [ ] `createHookContext()` and `createFrameworkContext()` both updated if FrameworkContext changed
-- [ ] No parallel code paths introduced (no duplicate CRUD, no duplicate registries)
-- [ ] Existing tests pass: `pnpm test`
-- [ ] Integration tests pass: `pnpm test:integration`
-- [ ] Full monorepo builds: `pnpm build`

package/.turbo/turbo-build.log

@@ -1,4 +0,0 @@
-
-> @rangka/core@0.1.0 build /home/runner/work/rangka-framework/rangka-framework/packages/core
-> tsc --build
-

package/CHANGELOG.md

@@ -1,18 +0,0 @@
-# @rangka/core
-
-## 0.1.0
-
-### Minor Changes
-
-- [`438bf4a`](https://github.com/rangka-dev/rangka-framework/commit/438bf4a385b99d1e497e937375dc03aac101c8ec) Thanks [@irfnmzk](https://github.com/irfnmzk)! - Initial open source release
-
-  - Modular ERP framework with declarative models, hooks, services, and widgets
-  - CLI with dev server, build, and studio commands
-  - Studio AI development environment with WebSocket-based UI
-  - create-rangka scaffolding tool
-  - MIT licensed framework, AGPL licensed studio
-
-### Patch Changes
-
-- Updated dependencies [[`438bf4a`](https://github.com/rangka-dev/rangka-framework/commit/438bf4a385b99d1e497e937375dc03aac101c8ec)]:
-  - @rangka/shared@0.1.0

package/CLAUDE.md

@@ -1,180 +0,0 @@
-# CLAUDE.md — @rangka/core
-
-## Package overview
-
-The Rangka server runtime. Handles boot, schema resolution, database sync, API routing, authentication, hooks, services, jobs, events, and plugins. This is the single source of truth for all server-side behavior.
-
-## Tech stack
-
-- Node.js >= 20, TypeScript 5
-- Fastify (HTTP server, routing, plugins)
-- Kysely (query builder, migrations, transactions)
-- PostgreSQL (only supported database)
-
-## Project structure
-
-```
-src/
-├── api/            — Fastify server creation, route generation, request handling
-├── audit/          — Audit trail recording
-├── auth/           — JWT sessions, permissions, scopes, field-level access, seed
-├── boot/           — Boot sequence: discovery, schema loading, merging, registry init
-├── db/             — DatabaseClient, auto-sync (DiffEngine), model-ops (Kysely CRUD)
-├── events/         — EventBus (in-process pub/sub with transaction support)
-├── external-model/ — Adapter-based external data sources
-├── fixtures/       — Seed data loading
-├── helpers/        — Shared utilities
-├── hooks/          — Hook registry, executor, middleware pipeline, context builder
-├── jobs/           — Job registry, worker, scheduler, enqueue
-├── model-api/      — Model access layer (query builder, filters, scopes, includes)
-├── plugins/        — Plugin lifecycle, adapter registry, loader
-├── schema/         — SchemaRegistry, relationship resolution, types
-├── services/       — ServiceRegistry, service definitions
-├── validation/     — Model-level validation rules
-├── widgets/        — Server-side widget registry (for studio)
-├── context.ts      — FrameworkContext builder
-├── errors.ts       — AppError base class
-└── index.ts        — Public exports
-```
-
-## Key registries (MUST reuse, never recreate)
-
-| Registry             | Location                      | Purpose                                                                             |
-| -------------------- | ----------------------------- | ----------------------------------------------------------------------------------- |
-| `SchemaRegistry`     | `schema/registry.ts`          | Holds all resolved models, relationships, field metadata. Single instance per boot. |
-| `PermissionRegistry` | `auth/permission-registry.ts` | Maps roles to model/field permissions.                                              |
-| `ScopeRegistry`      | `auth/scope-registry.ts`      | Defines scope filters per role (tenant isolation, ownership).                       |
-| `HookRegistry`       | `hooks/registry.ts`           | Stores validate/beforeSave/afterSave/beforeDelete/afterDelete hooks per model.      |
-| `ServiceRegistry`    | `services/registry.ts`        | Named service definitions, instantiated with context on call.                       |
-| `JobRegistry`        | `jobs/registry.ts`            | Background job handlers.                                                            |
-| `EventBus`           | `events/bus.ts`               | In-process event pub/sub with transaction-scoped emit.                              |
-| `AdapterRegistry`    | `plugins/adapter-registry.ts` | External data source adapters (REST, GraphQL, etc).                                 |
-| `WidgetRegistry`     | `widgets/widget-registry.ts`  | Server-side widget definitions for studio.                                          |
-
-## Model access layer
-
-All CRUD operations go through `createModelAccess()` in `model-api/index.ts`. This provides:
-
-- `models.get(model, id)` — fetch single record
-- `models.query(model)` — returns a `ModelQueryBuilder` with filter/sort/paginate/include
-- `models.create(model, data)` — insert with auth context
-- `models.update(model, id, data)` — update with auth context
-- `models.delete(model, id)` — delete with auth context
-
-The query builder handles:
-
-- Scope enforcement (`scope-enforcer.ts`) — auto-applies tenant/ownership filters
-- Field-level access (`field-access.ts`) — strips hidden fields, enforces readOnly
-- Filter translation (`filter-translator.ts`) — converts API filter syntax to Kysely where clauses
-- Include resolution (`include-resolver.ts`) — resolves relationships and external model joins
-
-Never write raw Kysely queries for model CRUD. Use `createModelAccess` or the existing `KyselyModelOps`.
-
-## Hook pipeline
-
-Hooks run inside a transaction via `hooks/executor.ts`:
-
-1. `validate` — can throw to reject the operation
-2. `beforeCreate` / `beforeUpdate` / `beforeSave` — can mutate the data before write
-3. (database write happens here)
-4. `afterCreate` / `afterUpdate` / `afterSave` — side effects after successful write
-5. `beforeDelete` / `afterDelete` — same pattern for deletes
-
-Hooks receive a `FrameworkContext` built by `hooks/context.ts`. This context provides: `db` (transaction), `schema`, `auth`, `models`, `events`, `config`, `service`, `enqueue`.
-
-Never create a parallel context builder. Use `createHookContext()`.
-
-## FrameworkContext (quick reference)
-
-This is the single object passed to all hooks, services, and jobs. Defined in `@rangka/shared/src/types/context.ts`, built by `src/hooks/context.ts`.
-
-```typescript
-interface FrameworkContext {
-  db: Kysely<unknown>; // transaction-scoped connection
-  schema: SchemaRegistryInterface; // model/field/relationship lookups
-  scope: unknown; // current tenant/scope value
-  models: ModelAccessInterface; // CRUD with scopes + permissions
-  events: { emit; on }; // transaction-scoped pub/sub
-  auth: { user; roles }; // current user identity
-  config: Record<string, unknown>; // app configuration
-  service: (name) => ServiceInstance; // call other services
-  enqueue: (job, data, opts?) => Promise<void>; // background jobs
-  notify: (channel, message) => void;
-  email: { send: (template, options) => Promise<void> };
-}
-```
-
-Rules:
-
-- All data access goes through `ctx.models` (not raw Kysely for CRUD)
-- All events go through `ctx.events.emit` (not custom pub/sub)
-- All background work goes through `ctx.enqueue` (not custom dispatchers)
-- All cross-service calls go through `ctx.service(name)` (not direct imports)
-- Use `ctx.db` directly ONLY for queries ModelQueryInterface cannot express (aggregations, complex joins)
-
-## Helper utilities (MUST reuse)
-
-| Utility                             | Location                        | Purpose                                       |
-| ----------------------------------- | ------------------------------- | --------------------------------------------- |
-| `stampCreate`                       | `helpers/stamping.ts`           | Adds `created_at`, `created_by` fields        |
-| `stampUpdate`                       | `helpers/stamping.ts`           | Adds `updated_at`, `updated_by` fields        |
-| `assertOwnership`                   | `helpers/assert-ownership.ts`   | Verifies record belongs to current user/scope |
-| `findMissingRequiredFields`         | `helpers/validation.ts`         | Checks required fields before write           |
-| `validateFields`                    | `validation/field-validator.ts` | Validates field values against schema         |
-| `BadRequestError` / `NotFoundError` | `errors.ts`                     | Standard error classes for API responses      |
-| `AppError`                          | `errors.ts`                     | Base error class with code + status           |
-
-Never recreate validation, stamping, or ownership logic. These helpers are used by the middleware layer and must be consistent.
-
-## Boot sequence
-
-`boot/index.ts` orchestrates startup:
-
-1. Discover apps (file system or programmatic)
-2. Load and merge schemas (YAML model definitions)
-3. Build SchemaRegistry with resolved relationships
-4. Create DatabaseClient, run autoSync (DDL diff)
-5. Create Fastify server
-6. Register all registries (hooks, services, jobs, permissions, scopes, events)
-7. Generate API routes from resolved models
-8. Load and initialize plugins
-
-## API route generation
-
-`api/route-generator.ts` auto-generates REST endpoints for every model:
-
-- `GET /api/{module}/{model}` — list with filters, sort, pagination
-- `GET /api/{module}/{model}/:id` — get by ID
-- `POST /api/{module}/{model}` — create
-- `PATCH /api/{module}/{model}/:id` — update
-- `DELETE /api/{module}/{model}/:id` — delete
-
-Custom routes are added via services or plugins. Never duplicate the auto-generated CRUD pattern.
-
-## Commands
-
-```bash
-pnpm --filter @rangka/core build    # Build → dist/
-pnpm --filter @rangka/core test     # Unit tests
-pnpm test:integration               # Integration tests (from repo root, needs PostgreSQL)
-pnpm test:integration -- tests/integration/path/to/file.test.ts  # Single integration test
-```
-
-## Skills available
-
-- **`extend-core`** — step-by-step for modifying core internals (registries, hook pipeline, route generator, FrameworkContext)
-
-Read this skill before modifying any core internal.
-
-## Don'ts
-
-- Don't write raw SQL — use Kysely query builder via `DatabaseClient` or `KyselyModelOps`
-- Don't bypass `createModelAccess` for CRUD — it enforces scopes and permissions
-- Don't create new registries — extend existing ones or add methods to them
-- Don't build a new context object — use `createHookContext()` or `createFrameworkContext()`
-- Don't add Fastify routes manually — use the route generator or service system
-- Don't duplicate filter/sort/pagination logic — use `ModelQueryBuilder`
-- Don't access `SchemaRegistry` fields directly — use its methods (`getModel`, `getRelationships`, etc.)
-- Don't add new hook phases — use the existing validate/beforeSave/afterSave/beforeDelete/afterDelete
-- Don't create new transaction boundaries inside hooks — hooks already run in a transaction
-- Don't import from `@rangka/client` — this is a server package, client is browser-only

package/src/__tests__/coerce.test.ts

@@ -1,154 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toBool, toInt, isNil, toCount } from '../helpers/coerce.js';
-
-describe('toBool', () => {
-  it('returns true for boolean true', () => {
-    expect(toBool(true)).toBe(true);
-  });
-
-  it('returns true for string "true"', () => {
-    expect(toBool('true')).toBe(true);
-  });
-
-  it('returns true for number 1', () => {
-    expect(toBool(1)).toBe(true);
-  });
-
-  it('returns true for string "1"', () => {
-    expect(toBool('1')).toBe(true);
-  });
-
-  it('returns false for boolean false', () => {
-    expect(toBool(false)).toBe(false);
-  });
-
-  it('returns false for string "false"', () => {
-    expect(toBool('false')).toBe(false);
-  });
-
-  it('returns false for 0', () => {
-    expect(toBool(0)).toBe(false);
-  });
-
-  it('returns false for null', () => {
-    expect(toBool(null)).toBe(false);
-  });
-
-  it('returns false for undefined', () => {
-    expect(toBool(undefined)).toBe(false);
-  });
-
-  it('returns false for empty string', () => {
-    expect(toBool('')).toBe(false);
-  });
-
-  it('returns false for arbitrary string', () => {
-    expect(toBool('yes')).toBe(false);
-  });
-});
-
-describe('toInt', () => {
-  it('returns the integer for a number', () => {
-    expect(toInt(42)).toBe(42);
-  });
-
-  it('truncates floating point numbers', () => {
-    expect(toInt(3.9)).toBe(3);
-    expect(toInt(-2.7)).toBe(-2);
-  });
-
-  it('parses numeric strings', () => {
-    expect(toInt('10')).toBe(10);
-    expect(toInt('  5 ')).toBe(5);
-  });
-
-  it('returns fallback for NaN values', () => {
-    expect(toInt('abc')).toBe(0);
-    expect(toInt('abc', -1)).toBe(-1);
-  });
-
-  it('returns fallback for null', () => {
-    expect(toInt(null)).toBe(0);
-    expect(toInt(null, 99)).toBe(99);
-  });
-
-  it('returns fallback for undefined', () => {
-    expect(toInt(undefined)).toBe(0);
-  });
-
-  it('returns fallback for Infinity', () => {
-    expect(toInt(Infinity)).toBe(0);
-    expect(toInt(-Infinity, 5)).toBe(5);
-  });
-
-  it('returns fallback for empty string', () => {
-    expect(toInt('')).toBe(0);
-  });
-
-  it('handles string with leading zeros', () => {
-    expect(toInt('007')).toBe(7);
-  });
-});
-
-describe('isNil', () => {
-  it('returns true for null', () => {
-    expect(isNil(null)).toBe(true);
-  });
-
-  it('returns true for undefined', () => {
-    expect(isNil(undefined)).toBe(true);
-  });
-
-  it('returns false for 0', () => {
-    expect(isNil(0)).toBe(false);
-  });
-
-  it('returns false for empty string', () => {
-    expect(isNil('')).toBe(false);
-  });
-
-  it('returns false for false', () => {
-    expect(isNil(false)).toBe(false);
-  });
-
-  it('returns false for NaN', () => {
-    expect(isNil(NaN)).toBe(false);
-  });
-
-  it('returns false for objects', () => {
-    expect(isNil({})).toBe(false);
-    expect(isNil([])).toBe(false);
-  });
-});
-
-describe('toCount', () => {
-  it('extracts count from object', () => {
-    expect(toCount({ count: '5' })).toBe(5);
-    expect(toCount({ count: 10 })).toBe(10);
-  });
-
-  it('returns 0 for null', () => {
-    expect(toCount(null)).toBe(0);
-  });
-
-  it('returns 0 for undefined', () => {
-    expect(toCount(undefined)).toBe(0);
-  });
-
-  it('returns 0 when count is missing', () => {
-    expect(toCount({})).toBe(0);
-  });
-
-  it('returns 0 when count is not a number', () => {
-    expect(toCount({ count: 'abc' })).toBe(0);
-  });
-
-  it('handles bigint-style string from database', () => {
-    expect(toCount({ count: '12345' })).toBe(12345);
-  });
-
-  it('handles raw numeric value without object wrapper', () => {
-    expect(toCount(7)).toBe(7);
-    expect(toCount('3')).toBe(3);
-  });
-});

package/src/__tests__/context.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createFrameworkContext, createRequestContext } from '../context.js';
-import { ServiceRegistry } from '../services/registry.js';
-import { EventBus } from '../events/bus.js';
-import { SchemaRegistry } from '../schema/registry.js';
-
-describe('createFrameworkContext', () => {
-  function setup() {
-    const kysely = { fake: 'db' } as any;
-    const db = {
-      kysely,
-      selectFrom: () => {},
-      insertInto: () => {},
-      updateTable: () => {},
-      deleteFrom: () => {},
-    } as any;
-    const schema = new SchemaRegistry([]);
-    const eventBus = new EventBus();
-    const serviceRegistry = new ServiceRegistry();
-    return { db, kysely, schema, eventBus, serviceRegistry };
-  }
-
-  it('returns context with all fields populated', () => {
-    const { db, kysely, schema, eventBus, serviceRegistry } = setup();
-    const ctx = createFrameworkContext({
-      db,
-      schema,
-      eventBus,
-      serviceRegistry,
-      config: { env: 'test' },
-    });
-
-    expect(ctx.db).toBe(kysely);
-    expect(ctx.schema).toBe(schema);
-    expect(ctx.events.emit).toBeTypeOf('function');
-    expect(ctx.events.on).toBeTypeOf('function');
-    expect(ctx.auth).toEqual({ user: null, roles: [] });
-    expect(ctx.config).toEqual({ env: 'test' });
-    expect(ctx.service).toBeTypeOf('function');
-    expect(ctx.enqueue).toBeTypeOf('function');
-    expect(ctx.notify).toBeTypeOf('function');
-    expect(ctx.email.send).toBeTypeOf('function');
-  });
-
-  it('service() resolves registered services', () => {
-    const { db, schema, eventBus, serviceRegistry } = setup();
-    serviceRegistry.register({
-      name: 'pricing',
-      factory: () => ({ calculate: (x: unknown) => x }),
-    });
-
-    const ctx = createFrameworkContext({ db, schema, eventBus, serviceRegistry });
-    const pricing = ctx.service('pricing');
-    expect(pricing.calculate(100)).toBe(100);
-  });
-
-  it('defaults config to empty object', () => {
-    const { db, schema, eventBus, serviceRegistry } = setup();
-    const ctx = createFrameworkContext({ db, schema, eventBus, serviceRegistry });
-    expect(ctx.config).toEqual({});
-  });
-});
-
-describe('createRequestContext', () => {
-  function setup() {
-    const kysely = { fake: 'db' } as any;
-    const db = {
-      kysely,
-      selectFrom: () => {},
-      insertInto: () => {},
-      updateTable: () => {},
-      deleteFrom: () => {},
-    } as any;
-    const schema = new SchemaRegistry([]);
-    const eventBus = new EventBus();
-    const serviceRegistry = new ServiceRegistry();
-    const base = createFrameworkContext({ db, schema, eventBus, serviceRegistry });
-    return { base, kysely };
-  }
-
-  it('inherits from base context', () => {
-    const { base } = setup();
-    const auth = { user: { id: '1', email: 'admin@test.com' } } as any;
-    const reqCtx = createRequestContext({ base, auth, roles: ['Administrator'] });
-
-    expect(reqCtx.schema).toBe(base.schema);
-    expect(reqCtx.service).toBe(base.service);
-    expect(reqCtx.auth).toEqual({
-      user: { id: '1', email: 'admin@test.com' },
-      roles: ['Administrator'],
-    });
-  });
-
-  it('uses transaction db when provided', () => {
-    const { base } = setup();
-    const trx = { fake: 'trx' } as any;
-    const auth = {} as any;
-    const reqCtx = createRequestContext({ base, auth, trx });
-
-    expect(reqCtx.db).toBe(trx);
-    expect(reqCtx.db).not.toBe(base.db);
-  });
-
-  it('uses base db when no transaction provided', () => {
-    const { base } = setup();
-    const auth = {} as any;
-    const reqCtx = createRequestContext({ base, auth });
-
-    expect(reqCtx.db).toBe(base.db);
-  });
-});

package/src/__tests__/helpers.ts

@@ -1,21 +0,0 @@
-import Fastify, { type FastifyInstance, type FastifyError } from 'fastify';
-import { AppError } from '../errors.js';
-
-export function createTestServer(): FastifyInstance {
-  const server = Fastify();
-  server.setErrorHandler((error: FastifyError | AppError, request, reply) => {
-    if (error instanceof AppError) {
-      return reply.status(error.statusCode).send({
-        error: {
-          code: error.code,
-          message: error.message,
-          ...(error.details !== undefined && { details: error.details }),
-        },
-      });
-    }
-    reply.status(error.statusCode ?? 500).send({
-      error: { code: 'INTERNAL_ERROR', message: error.message },
-    });
-  });
-  return server;
-}

package/src/__tests__/index.test.ts

@@ -1,7 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('@rangka/core', () => {
-  it('should be importable', () => {
-    expect(true).toBe(true);
-  });
-});