@rangka/core 0.0.1

package/src/context.ts

@@ -0,0 +1,105 @@
+import type { Kysely } from 'kysely';
+import type { FrameworkContext } from '@rangka/shared';
+import type { SchemaRegistry } from './schema/registry.js';
+import type { EventBus } from './events/bus.js';
+import type { RequestContext } from './auth/types.js';
+import type { ServiceRegistry } from './services/registry.js';
+import type { AdapterRegistry } from './plugins/adapter-registry.js';
+import type { DatabaseClient } from './db/client.js';
+import { enqueue } from './jobs/enqueue.js';
+import { createModelAccess } from './model-api/index.js';
+
+export interface FrameworkContextOptions {
+  db: DatabaseClient;
+  schema: SchemaRegistry;
+  eventBus: EventBus;
+  serviceRegistry: ServiceRegistry;
+  config?: Record<string, unknown>;
+  adapterRegistry?: AdapterRegistry;
+}
+
+/**
+ * Creates the root framework context used by services, hooks, and jobs.
+ * This context has no authenticated user — use createRequestContext to add auth.
+ */
+export function createFrameworkContext(opts: FrameworkContextOptions): FrameworkContext {
+  const { db, schema, eventBus, serviceRegistry, config = {}, adapterRegistry } = opts;
+
+  const events = {
+    emit: async (event: string, payload: unknown) => {
+      await eventBus.emit(event, payload);
+    },
+    on: (event: string, handler: (payload: unknown) => Promise<void>) => {
+      eventBus.on(event, handler);
+    },
+  };
+
+  const enqueueJob = async (
+    job: string,
+    data: unknown,
+    opts?: { delay?: number; unique?: boolean; uniqueKey?: string },
+  ) => {
+    await enqueue(db.kysely, job, data, opts);
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const models = createModelAccess({ db: db as any, registry: schema, adapterRegistry });
+
+  const serviceContext = {
+    db: db.kysely,
+    schema,
+    enqueue: enqueueJob,
+    events,
+    config,
+    models,
+    auth: { user: null, roles: [] as string[] },
+    scope: null,
+  };
+
+  return {
+    db: db.kysely,
+    schema,
+    scope: null,
+    models,
+    events,
+    auth: { user: null, roles: [] },
+    config,
+    service: (name: string) => serviceRegistry.get(name, serviceContext),
+    enqueue: enqueueJob,
+    notify: () => {},
+    email: { send: async () => {} },
+  };
+}
+
+export interface RequestScopedContextOptions {
+  base: FrameworkContext;
+  auth: RequestContext;
+  roles?: string[];
+  trx?: Kysely<unknown>;
+  adapterRegistry?: AdapterRegistry;
+}
+
+/**
+ * Creates a request-scoped context by layering authentication info
+ * and an optional transaction on top of the base framework context.
+ */
+export function createRequestContext(opts: RequestScopedContextOptions): FrameworkContext {
+  const { base, auth, roles = [], trx, adapterRegistry } = opts;
+  const dbInstance = trx ?? (base.db as Kysely<unknown>);
+  const models = createModelAccess({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    db: dbInstance as any,
+    registry: base.schema as unknown as SchemaRegistry,
+    auth,
+    adapterRegistry,
+  });
+  return {
+    ...base,
+    db: dbInstance,
+    models,
+    auth: {
+      user: auth.user ?? null,
+      roles,
+    },
+  };
+}

package/src/db/__tests__/cascade-delete.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { KyselyModelOps } from '../model-ops.js';
+import type { ResolvedModel } from '../../schema/types.js';
+import type { SchemaRegistry } from '../../schema/registry.js';
+
+function createMockDb() {
+  const executeFn = vi.fn().mockResolvedValue([]);
+  const executeTakeFirstFn = vi.fn();
+  const whereFn = vi.fn().mockReturnValue({ execute: executeFn });
+  const setFn = vi.fn().mockReturnValue({ where: whereFn });
+  const deleteWhereFn = vi.fn().mockReturnValue({ execute: executeFn });
+
+  const selectWhereFn = vi.fn();
+  const selectAllFn = vi.fn();
+
+  selectWhereFn.mockImplementation(() => ({
+    executeTakeFirst: executeTakeFirstFn,
+    where: selectWhereFn,
+  }));
+  selectAllFn.mockReturnValue({ where: selectWhereFn });
+
+  const db = {
+    selectFrom: vi.fn().mockReturnValue({ selectAll: selectAllFn }),
+    insertInto: vi.fn(),
+    updateTable: vi.fn().mockReturnValue({ set: setFn }),
+    deleteFrom: vi.fn().mockReturnValue({ where: deleteWhereFn }),
+  };
+
+  return { db, executeFn, executeTakeFirstFn, setFn, whereFn, deleteWhereFn };
+}
+
+function createParentModel(
+  traits: string[] = [],
+  childrenFields: ResolvedModel['fields'] = [],
+): ResolvedModel {
+  return {
+    qualifiedName: 'sales.invoice',
+    app: 'sales',
+    module: 'sales',
+    name: 'invoice',
+    auditLog: false,
+    traits,
+    fields: [
+      { name: 'id', config: { type: 'string' }, provenance: { source: 'base' } },
+      { name: 'customer', config: { type: 'string' }, provenance: { source: 'base' } },
+      ...childrenFields,
+    ],
+    indexes: [],
+  };
+}
+
+describe('KyselyModelOps cascade delete children', () => {
+  let mockRegistry: SchemaRegistry;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockRegistry = {
+      getModel: vi.fn().mockReturnValue(null),
+    } as unknown as SchemaRegistry;
+  });
+
+  it('hard deletes children when parent is hard deleted', async () => {
+    const { db, executeTakeFirstFn, deleteWhereFn } = createMockDb();
+    executeTakeFirstFn.mockResolvedValue({ id: 'inv-1', customer: 'cust-1' });
+
+    const model = createParentModel(
+      [],
+      [
+        {
+          name: 'items',
+          config: { type: 'children', model: 'sales.invoice_item', foreignKey: 'invoice_id' },
+          provenance: { source: 'base' },
+        },
+      ],
+    );
+
+    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
+    await ops.delete('inv-1');
+
+    expect(db.deleteFrom).toHaveBeenCalledWith('sales__invoice_item');
+    expect(deleteWhereFn).toHaveBeenCalledWith('invoice_id', '=', 'inv-1');
+  });
+
+  it('soft deletes children when child model has soft_delete trait', async () => {
+    const { db, executeTakeFirstFn, setFn, whereFn } = createMockDb();
+    executeTakeFirstFn.mockResolvedValue({ id: 'inv-1', customer: 'cust-1' });
+
+    (mockRegistry.getModel as any).mockImplementation((name: string) => {
+      if (name === 'sales.invoice_item') {
+        return { traits: ['soft_delete'] };
+      }
+      return null;
+    });
+
+    const model = createParentModel(
+      [],
+      [
+        {
+          name: 'items',
+          config: { type: 'children', model: 'sales.invoice_item', foreignKey: 'invoice_id' },
+          provenance: { source: 'base' },
+        },
+      ],
+    );
+
+    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
+    await ops.delete('inv-1');
+
+    expect(db.updateTable).toHaveBeenCalledWith('sales__invoice_item');
+    expect(setFn).toHaveBeenCalledWith({ archived_at: expect.any(String) });
+    expect(whereFn).toHaveBeenCalledWith('invoice_id', '=', 'inv-1');
+  });
+
+  it('cascades to multiple children fields', async () => {
+    const { db, executeTakeFirstFn, deleteWhereFn } = createMockDb();
+    executeTakeFirstFn.mockResolvedValue({ id: 'inv-1' });
+
+    const model = createParentModel(
+      [],
+      [
+        {
+          name: 'items',
+          config: { type: 'children', model: 'sales.invoice_item', foreignKey: 'invoice_id' },
+          provenance: { source: 'base' },
+        },
+        {
+          name: 'taxes',
+          config: { type: 'children', model: 'sales.invoice_tax', foreignKey: 'invoice_id' },
+          provenance: { source: 'base' },
+        },
+      ],
+    );
+
+    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
+    await ops.delete('inv-1');
+
+    expect(db.deleteFrom).toHaveBeenCalledWith('sales__invoice_item');
+    expect(db.deleteFrom).toHaveBeenCalledWith('sales__invoice_tax');
+    expect(deleteWhereFn).toHaveBeenCalledTimes(3); // 2 children + 1 parent
+  });
+
+  it('does not cascade when model has no children fields', async () => {
+    const { db, executeTakeFirstFn, deleteWhereFn } = createMockDb();
+    executeTakeFirstFn.mockResolvedValue({ id: 'inv-1' });
+
+    const model = createParentModel();
+
+    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
+    await ops.delete('inv-1');
+
+    expect(db.deleteFrom).toHaveBeenCalledTimes(1); // only parent
+    expect(deleteWhereFn).toHaveBeenCalledWith('id', '=', 'inv-1');
+  });
+
+  it('soft deletes parent and hard deletes children when only parent has soft_delete', async () => {
+    const { db, executeTakeFirstFn, setFn, whereFn, deleteWhereFn } = createMockDb();
+    executeTakeFirstFn.mockResolvedValue({ id: 'inv-1' });
+
+    const model = createParentModel(
+      ['soft_delete'],
+      [
+        {
+          name: 'items',
+          config: { type: 'children', model: 'sales.invoice_item', foreignKey: 'invoice_id' },
+          provenance: { source: 'base' },
+        },
+      ],
+    );
+
+    const ops = new KyselyModelOps({ db, model, registry: mockRegistry });
+    await ops.delete('inv-1');
+
+    // Children hard deleted
+    expect(db.deleteFrom).toHaveBeenCalledWith('sales__invoice_item');
+    expect(deleteWhereFn).toHaveBeenCalledWith('invoice_id', '=', 'inv-1');
+
+    // Parent soft deleted
+    expect(db.updateTable).toHaveBeenCalledWith('sales.invoice');
+    expect(setFn).toHaveBeenCalledWith({ archived_at: expect.any(String) });
+    expect(whereFn).toHaveBeenCalledWith('id', '=', 'inv-1');
+  });
+});

package/src/db/__tests__/desired-state.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from 'vitest';
+import { SchemaToDesired } from '../desired-state.js';
+import { SchemaRegistry } from '../../schema/registry.js';
+import type { ResolvedModel } from '../../schema/types.js';
+
+function makeModel(overrides: Partial<ResolvedModel> = {}): ResolvedModel {
+  return {
+    qualifiedName: 'sales.invoice',
+    app: 'sales',
+    module: 'sales',
+    name: 'invoice',
+    auditLog: true,
+    traits: [],
+    fields: [],
+    indexes: [],
+    ...overrides,
+  };
+}
+
+function makeRegistry(models: ResolvedModel[]): SchemaRegistry {
+  return new SchemaRegistry(models);
+}
+
+describe('SchemaToDesired', () => {
+  const converter = new SchemaToDesired();
+
+  it('converts simple model to table definition', () => {
+    const registry = makeRegistry([
+      makeModel({
+        fields: [
+          {
+            name: 'title',
+            config: { type: 'string', maxLength: 200 },
+            provenance: { source: 'base' },
+          },
+          { name: 'amount', config: { type: 'decimal' }, provenance: { source: 'base' } },
+        ],
+      }),
+    ]);
+
+    const state = converter.convert(registry);
+    const userTables = state.tables.filter((t) => !t.name.startsWith('rangka_'));
+    expect(userTables).toHaveLength(1);
+    expect(userTables[0].name).toBe('sales__invoice');
+    expect(userTables[0].columns.find((c) => c.name === 'id')).toBeDefined();
+    expect(state.tables[0].columns.find((c) => c.name === 'title')).toBeDefined();
+    expect(state.tables[0].columns.find((c) => c.name === 'amount')).toBeDefined();
+  });
+
+  it('maps table name using double underscore', () => {
+    const registry = makeRegistry([makeModel({ qualifiedName: 'accounting.journal_entry' })]);
+
+    const state = converter.convert(registry);
+    expect(state.tables[0].name).toBe('accounting__journal_entry');
+  });
+
+  it('generates indexes from model config', () => {
+    const registry = makeRegistry([
+      makeModel({
+        indexes: [{ fields: ['customer', 'posting_date'] }, { fields: ['email'], unique: true }],
+      }),
+    ]);
+
+    const state = converter.convert(registry);
+    const indexes = state.tables[0].indexes;
+    expect(indexes).toHaveLength(2);
+    expect(indexes[0].name).toBe('idx_sales__invoice_customer_posting_date');
+    expect(indexes[0].unique).toBe(false);
+    expect(indexes[1].name).toBe('uidx_sales__invoice_email');
+    expect(indexes[1].unique).toBe(true);
+  });
+
+  it('generates naming_sequence table when sequence fields exist', () => {
+    const registry = makeRegistry([
+      makeModel({
+        fields: [
+          {
+            name: 'invoice_number',
+            config: { type: 'sequence', prefix: 'INV-', digits: 5 },
+            provenance: { source: 'base' },
+          },
+        ],
+      }),
+    ]);
+
+    const state = converter.convert(registry);
+    const seqTable = state.tables.find((t) => t.name === 'naming_sequence');
+    expect(seqTable).toBeDefined();
+    expect(seqTable!.columns.map((c) => c.name)).toEqual([
+      'model',
+      'field',
+      'next_val',
+    ]);
+    expect(seqTable!.indexes[0].unique).toBe(true);
+  });
+
+  it('does not generate naming_sequence table when no sequence fields', () => {
+    const registry = makeRegistry([
+      makeModel({
+        fields: [{ name: 'title', config: { type: 'string' }, provenance: { source: 'base' } }],
+      }),
+    ]);
+
+    const state = converter.convert(registry);
+    expect(state.tables.find((t) => t.name === 'naming_sequence')).toBeUndefined();
+  });
+
+  it('includes extra tables from closure_table tree strategy', () => {
+    const registry = makeRegistry([
+      makeModel({
+        fields: [
+          {
+            name: 'parent',
+            config: { type: 'tree', parentField: 'parent_id', strategy: 'closure_table' },
+            provenance: { source: 'base' },
+          },
+        ],
+      }),
+    ]);
+
+    const state = converter.convert(registry);
+    expect(state.tables.find((t) => t.name === 'sales__invoice_closure')).toBeDefined();
+  });
+
+  it('handles multiple models', () => {
+    const registry = makeRegistry([
+      makeModel({ qualifiedName: 'sales.invoice', name: 'invoice' }),
+      makeModel({ qualifiedName: 'sales.customer', name: 'customer' }),
+    ]);
+
+    const state = converter.convert(registry);
+    const userTables = state.tables.filter((t) => !t.name.startsWith('rangka_'));
+    expect(userTables).toHaveLength(2);
+    expect(userTables.map((t) => t.name).sort()).toEqual(['sales__customer', 'sales__invoice']);
+  });
+});