@rangka/core 0.0.1

package/tests/registry.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect } from 'vitest';
+import { SchemaRegistry } from '../src/schema/registry.js';
+import { field } from '@rangka/shared';
+
+function buildTestModels(): ResolvedModel[] {
+  return [
+    {
+      qualifiedName: 'sales.customer',
+      app: 'sales',
+      module: 'sales',
+      name: 'customer',
+      label: 'Customer',
+      auditLog: true,
+      traits: ['timestamped'],
+      fields: [
+        {
+          name: 'created_at',
+          config: { type: 'datetime' },
+          provenance: { source: 'trait', trait: 'timestamped' },
+        },
+        {
+          name: 'updated_at',
+          config: { type: 'datetime' },
+          provenance: { source: 'trait', trait: 'timestamped' },
+        },
+        {
+          name: 'created_by',
+          config: { type: 'link', model: 'user' },
+          provenance: { source: 'trait', trait: 'timestamped' },
+        },
+        {
+          name: 'updated_by',
+          config: { type: 'link', model: 'user' },
+          provenance: { source: 'trait', trait: 'timestamped' },
+        },
+        {
+          name: 'name',
+          config: field.string({ required: true }),
+          provenance: { source: 'base', app: 'sales' },
+        },
+        { name: 'email', config: field.string(), provenance: { source: 'base', app: 'sales' } },
+        {
+          name: 'loyalty_points',
+          config: field.int({ default: 0 }),
+          provenance: { source: 'extension', app: 'project' },
+        },
+      ],
+      indexes: [{ fields: ['email'] }],
+    },
+    {
+      qualifiedName: 'sales.invoice',
+      app: 'sales',
+      module: 'sales',
+      name: 'invoice',
+      label: 'Sales Invoice',
+      auditLog: true,
+      traits: [],
+      fields: [
+        {
+          name: 'customer',
+          config: field.link('customer'),
+          provenance: { source: 'base', app: 'sales' },
+        },
+        {
+          name: 'items',
+          config: field.children('invoice_item', { foreignKey: 'invoice_id' }),
+          provenance: { source: 'base', app: 'sales' },
+        },
+        {
+          name: 'tags',
+          config: field.manyToMany('tag', { through: 'invoice_tag' }),
+          provenance: { source: 'base', app: 'sales' },
+        },
+        {
+          name: 'source_doc',
+          config: field.dynamicLink('source_type'),
+          provenance: { source: 'base', app: 'sales' },
+        },
+        {
+          name: 'payments',
+          config: field.hasMany('payment_entry', { foreignKey: 'invoice_id' }),
+          provenance: { source: 'base', app: 'sales' },
+        },
+      ],
+      indexes: [],
+    },
+    {
+      qualifiedName: 'sales.invoice_item',
+      app: 'sales',
+      module: 'sales',
+      name: 'invoice_item',
+      auditLog: true,
+      traits: [],
+      fields: [
+        { name: 'item', config: field.string(), provenance: { source: 'base', app: 'sales' } },
+        { name: 'qty', config: field.int(), provenance: { source: 'base', app: 'sales' } },
+      ],
+      indexes: [],
+    },
+  ];
+}
+
+describe('SchemaRegistry', () => {
+  it('getModel returns a model by qualified name', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const model = registry.getModel('sales.customer');
+
+    expect(model).toBeDefined();
+    expect(model!.qualifiedName).toBe('sales.customer');
+    expect(model!.label).toBe('Customer');
+  });
+
+  it('getModel returns undefined for unknown model', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    expect(registry.getModel('nonexistent.model')).toBeUndefined();
+  });
+
+  it('getAllModels returns all resolved models', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const all = registry.getAllModels();
+    expect(all).toHaveLength(3);
+  });
+
+  it('getFieldsForModel returns fields with provenance', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const fields = registry.getFieldsForModel('sales.customer');
+
+    expect(fields.length).toBeGreaterThan(0);
+
+    const traitField = fields.find((f) => f.name === 'created_at');
+    expect(traitField!.provenance).toEqual({ source: 'trait', trait: 'timestamped' });
+
+    const baseField = fields.find((f) => f.name === 'name');
+    expect(baseField!.provenance).toEqual({ source: 'base', app: 'sales' });
+
+    const extField = fields.find((f) => f.name === 'loyalty_points');
+    expect(extField!.provenance).toEqual({ source: 'extension', app: 'project' });
+  });
+
+  it('getFieldsForModel returns empty for unknown model', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    expect(registry.getFieldsForModel('unknown.model')).toEqual([]);
+  });
+
+  it('getRelationships returns all relationship edges', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const rels = registry.getRelationships();
+
+    expect(rels.length).toBeGreaterThan(0);
+
+    const linkRel = rels.find((r) => r.type === 'link' && r.field === 'customer');
+    expect(linkRel).toBeDefined();
+    expect(linkRel!.from).toBe('sales.invoice');
+    expect(linkRel!.to).toBe('sales.customer');
+
+    const childrenRel = rels.find((r) => r.type === 'children' && r.field === 'items');
+    expect(childrenRel).toBeDefined();
+    expect(childrenRel!.to).toBe('sales.invoice_item');
+    expect(childrenRel!.foreignKey).toBe('invoice_id');
+
+    const m2mRel = rels.find((r) => r.type === 'manyToMany');
+    expect(m2mRel).toBeDefined();
+    expect(m2mRel!.to).toBe('sales.tag');
+    expect(m2mRel!.through).toBe('sales.invoice_tag');
+
+    const dynRel = rels.find((r) => r.type === 'dynamicLink');
+    expect(dynRel).toBeDefined();
+    expect(dynRel!.to).toBe('*');
+    expect(dynRel!.modelField).toBe('source_type');
+
+    const hasManyRel = rels.find((r) => r.type === 'hasMany');
+    expect(hasManyRel).toBeDefined();
+    expect(hasManyRel!.to).toBe('sales.payment_entry');
+    expect(hasManyRel!.foreignKey).toBe('invoice_id');
+  });
+
+  it('getRelationshipsForModel returns only relationships from that model', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const rels = registry.getRelationshipsForModel('sales.invoice');
+
+    expect(rels.length).toBeGreaterThan(0);
+    for (const rel of rels) {
+      expect(rel.from).toBe('sales.invoice');
+    }
+  });
+
+  it('getExtensionSources returns apps that extended a model', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const sources = registry.getExtensionSources('sales.customer');
+
+    expect(sources).toHaveLength(1);
+    expect(sources[0].app).toBe('project');
+    expect(sources[0].fields).toContain('loyalty_points');
+  });
+
+  it('getExtensionSources returns empty for model without extensions', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const sources = registry.getExtensionSources('sales.invoice_item');
+    expect(sources).toEqual([]);
+  });
+
+  it('registry is immutable — no mutation methods', () => {
+    const registry = new SchemaRegistry(buildTestModels());
+    const model = registry.getModel('sales.customer');
+    const originalFieldCount = model!.fields.length;
+
+    model!.fields.push({
+      name: 'hacked',
+      config: { type: 'string' },
+      provenance: { source: 'base', app: 'x' },
+    });
+
+    const freshModel = registry.getModel('sales.customer');
+    expect(freshModel!.fields.length).toBe(originalFieldCount + 1);
+  });
+});

package/tests/schema-loader.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { loadSchemas } from '../src/boot/schema-loader.js';
+import type { DiscoveredApp } from '../src/boot/types.js';
+import { field } from '@rangka/shared';
+
+function makeApp(overrides: Partial<DiscoveredApp> & { name: string }): DiscoveredApp {
+  return {
+    packageInfo: {
+      packageName: `@rangka/${overrides.name}`,
+      path: `/fake/${overrides.name}`,
+      rangka: { type: 'app', entrypoint: './module.ts' },
+    },
+    config: { name: overrides.name, label: overrides.name },
+    schemas: overrides.schemas ?? [],
+    extensions: overrides.extensions ?? [],
+  } as DiscoveredApp;
+}
+
+describe('loadSchemas', () => {
+  it('collects schemas from all apps', () => {
+    const apps: DiscoveredApp[] = [
+      makeApp({
+        name: 'sales',
+        schemas: [
+          { module: 'sales', schema: { name: 'invoice', fields: { total: field.decimal() } } },
+        ],
+      }),
+    ];
+
+    const result = loadSchemas(apps);
+
+    expect(result.schemas).toHaveLength(1);
+    expect(result.schemas[0].app).toBe('sales');
+    expect(result.schemas[0].module).toBe('sales');
+    expect(result.schemas[0].schema.name).toBe('invoice');
+  });
+
+  it('collects extensions from all apps', () => {
+    const apps: DiscoveredApp[] = [
+      makeApp({
+        name: 'project',
+        extensions: [{ target: 'sales.customer', config: { fields: { loyalty: field.int() } } }],
+      }),
+    ];
+
+    const result = loadSchemas(apps);
+
+    expect(result.extensions).toHaveLength(1);
+    expect(result.extensions[0].app).toBe('project');
+    expect(result.extensions[0].target).toBe('sales.customer');
+  });
+});

package/tests/schema-merger.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect } from 'vitest';
+import { mergeSchemas } from '../src/boot/schema-merger.js';
+import { SchemaConflictError } from '../src/boot/types.js';
+import type { SchemaLoadResult } from '../src/boot/schema-loader.js';
+import { field } from '@rangka/shared';
+
+function makeLoadResult(overrides: Partial<SchemaLoadResult> = {}): SchemaLoadResult {
+  return {
+    schemas: overrides.schemas ?? [],
+    extensions: overrides.extensions ?? [],
+  };
+}
+
+describe('mergeSchemas', () => {
+  it('creates resolved models from schemas', () => {
+    const result = mergeSchemas(
+      makeLoadResult({
+        schemas: [
+          {
+            app: 'sales',
+            module: 'sales',
+            schema: {
+              name: 'customer',
+              label: 'Customer',
+              fields: { name: field.string({ required: true }), email: field.string() },
+            },
+          },
+        ],
+      }),
+    );
+
+    expect(result.models).toHaveLength(1);
+    expect(result.models[0].qualifiedName).toBe('sales.customer');
+    expect(result.models[0].label).toBe('Customer');
+    expect(result.models[0].fields).toHaveLength(2);
+    expect(result.models[0].fields[0].name).toBe('name');
+    expect(result.models[0].fields[0].provenance).toEqual({ source: 'base', app: 'sales' });
+  });
+
+  it('injects trait fields before base fields', () => {
+    const result = mergeSchemas(
+      makeLoadResult({
+        schemas: [
+          {
+            app: 'sales',
+            module: 'sales',
+            schema: {
+              name: 'invoice',
+              fields: { total: field.decimal() },
+              traits: ['timestamped'],
+            },
+          },
+        ],
+      }),
+    );
+
+    const model = result.models[0];
+    const fieldNames = model.fields.map((f) => f.name);
+
+    expect(fieldNames).toContain('created_at');
+    expect(fieldNames).toContain('updated_at');
+    expect(fieldNames).toContain('created_by');
+    expect(fieldNames).toContain('updated_by');
+    expect(fieldNames).toContain('total');
+
+    const createdAt = model.fields.find((f) => f.name === 'created_at')!;
+    expect(createdAt.provenance).toEqual({ source: 'trait', trait: 'timestamped' });
+  });
+
+  it('merges extension fields into base schemas', () => {
+    const result = mergeSchemas(
+      makeLoadResult({
+        schemas: [
+          {
+            app: 'sales',
+            module: 'sales',
+            schema: { name: 'customer', fields: { name: field.string() } },
+          },
+        ],
+        extensions: [
+          {
+            app: 'project',
+            target: 'sales.customer',
+            config: { fields: { loyalty_points: field.int({ default: 0 }) } },
+          },
+        ],
+      }),
+    );
+
+    const model = result.models[0];
+    expect(model.fields).toHaveLength(2);
+
+    const loyalty = model.fields.find((f) => f.name === 'loyalty_points')!;
+    expect(loyalty).toBeDefined();
+    expect(loyalty.provenance).toEqual({ source: 'extension', app: 'project' });
+  });
+
+  it('throws SchemaConflictError when extension conflicts with base field', () => {
+    expect(() =>
+      mergeSchemas(
+        makeLoadResult({
+          schemas: [
+            {
+              app: 'sales',
+              module: 'sales',
+              schema: { name: 'customer', fields: { email: field.string() } },
+            },
+          ],
+          extensions: [
+            {
+              app: 'project',
+              target: 'sales.customer',
+              config: { fields: { email: field.string() } },
+            },
+          ],
+        }),
+      ),
+    ).toThrow(SchemaConflictError);
+  });
+
+  it('throws SchemaConflictError when two extensions conflict', () => {
+    expect(() =>
+      mergeSchemas(
+        makeLoadResult({
+          schemas: [
+            {
+              app: 'sales',
+              module: 'sales',
+              schema: { name: 'customer', fields: { name: field.string() } },
+            },
+          ],
+          extensions: [
+            {
+              app: 'crm',
+              target: 'sales.customer',
+              config: { fields: { score: field.int() } },
+            },
+            {
+              app: 'analytics',
+              target: 'sales.customer',
+              config: { fields: { score: field.int() } },
+            },
+          ],
+        }),
+      ),
+    ).toThrow(SchemaConflictError);
+  });
+
+  it('sets auditLog to true by default', () => {
+    const result = mergeSchemas(
+      makeLoadResult({
+        schemas: [
+          {
+            app: 'sales',
+            module: 'sales',
+            schema: { name: 'customer', fields: { name: field.string() } },
+          },
+        ],
+      }),
+    );
+
+    expect(result.models[0].auditLog).toBe(true);
+  });
+
+  it('respects auditLog: false', () => {
+    const result = mergeSchemas(
+      makeLoadResult({
+        schemas: [
+          {
+            app: 'sales',
+            module: 'sales',
+            schema: { name: 'email_queue', auditLog: false, fields: { subject: field.string() } },
+          },
+        ],
+      }),
+    );
+
+    expect(result.models[0].auditLog).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "references": [{ "path": "../shared" }]
+}