@rangka/core 0.1.1 → 0.1.3

package/src/context.ts

@@ -1,105 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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']);
-  });
-});