@rangka/core 0.1.0 → 0.1.2

package/tests/registry.test.ts

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

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

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

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