@asteby/metacore-runtime-react 9.0.0 → 9.2.0

package/src/use-org-config-bridge.ts

@@ -0,0 +1,60 @@
+// Bridge to `useOrgConfig` from `@asteby/metacore-app-providers` without
+// adding it as a hard dependency of `runtime-react`. The provider package
+// is a peer; in apps that mount it the hook returns the live config, in
+// apps that don't the SDK falls through to a no-op shim that resolves
+// every reference to null. Forms then leave $org.<key> tokens in place
+// rather than crashing — the operator notices the missing config when
+// the validator fails to fire, not at app boot.
+//
+// Why a bridge: runtime-react cannot import `@asteby/metacore-app-providers`
+// directly without inverting the dependency graph (app-providers depends
+// on runtime-react today via peerDependenciesMeta). The shim shape
+// matches `OrgConfigContextValue` so DynamicForm code reads through one
+// stable interface regardless of provider mount.
+
+export interface OrgConfigBridge {
+    /** Resolves a `$org.<key>` reference (or plain key) to a literal id. */
+    resolveValidator: (refOrKey: string) => string | null
+    /** When true the app actually has a provider mounted. */
+    available: boolean
+}
+
+const NULL_BRIDGE: OrgConfigBridge = {
+    resolveValidator: () => null,
+    available: false,
+}
+
+let activeBridge: OrgConfigBridge = NULL_BRIDGE
+
+/**
+ * Apps that consume `runtime-react` AND `@asteby/metacore-app-providers`
+ * call this once near the root (typically inside the OrgConfigProvider
+ * children) so the SDK reads the same resolver. Hosts without an org
+ * provider can ignore this entirely; the SDK's null bridge keeps every
+ * call returning `null` so $org.<key> tokens stay verbatim in the form
+ * — same fallback the kernel uses for unresolved references.
+ */
+export function setOrgConfigBridge(bridge: OrgConfigBridge | null) {
+    activeBridge = bridge ?? NULL_BRIDGE
+}
+
+/**
+ * Returns the active bridge. Pure read — no React hook so it can be
+ * called from non-component code (zod schema builders, helpers).
+ */
+export function getOrgConfigBridge(): OrgConfigBridge {
+    return activeBridge
+}
+
+/**
+ * Resolves a Validation token into the validator identifier the SDK
+ * should apply. Returns the resolved literal when the org config knows
+ * the key, or the original token when it doesn't (so apps can decide).
+ * Plain literals (no `$org.` prefix) pass through.
+ */
+export function resolveValidatorToken(token: string | undefined | null): string | null {
+    if (!token) return null
+    if (!token.startsWith('$org.')) return token
+    const resolved = activeBridge.resolveValidator(token)
+    return resolved ?? token
+}

package/tsconfig.json

@@ -12,5 +12,6 @@
     "outDir": "./dist",
     "rootDir": "./src"
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts", "src/**/__tests__/**"]
 }

package/dist/__tests__/dynamic-form.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dynamic-form.test.d.ts.map

package/dist/__tests__/dynamic-form.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dynamic-form.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/dynamic-form.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/dynamic-form.test.js

@@ -1,93 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildZodSchema, resolveWidget } from '../dynamic-form-schema';
-describe('buildZodSchema', () => {
-    it('aplica regex de Validation a strings', () => {
-        const fields = [
-            { key: 'sku', label: 'SKU', type: 'string', required: true, validation: { regex: '^[A-Z]{3}-\\d{3}$' } },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ sku: 'ABC-123' }).success).toBe(true);
-        expect(schema.safeParse({ sku: 'abc-123' }).success).toBe(false);
-        expect(schema.safeParse({ sku: 'ABCD-123' }).success).toBe(false);
-    });
-    it('aplica min/max como longitud sobre strings', () => {
-        const fields = [
-            { key: 'name', label: 'Nombre', type: 'string', required: true, validation: { min: 3, max: 8 } },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ name: 'ab' }).success).toBe(false);
-        expect(schema.safeParse({ name: 'abc' }).success).toBe(true);
-        expect(schema.safeParse({ name: 'abcdefgh' }).success).toBe(true);
-        expect(schema.safeParse({ name: 'abcdefghi' }).success).toBe(false);
-    });
-    it('aplica min/max como bounds sobre números', () => {
-        const fields = [
-            { key: 'age', label: 'Edad', type: 'number', required: true, validation: { min: 18, max: 99 } },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ age: 17 }).success).toBe(false);
-        expect(schema.safeParse({ age: 18 }).success).toBe(true);
-        expect(schema.safeParse({ age: 99 }).success).toBe(true);
-        expect(schema.safeParse({ age: 100 }).success).toBe(false);
-    });
-    it('marca campos requeridos vacíos como inválidos', () => {
-        const fields = [
-            { key: 'title', label: 'Título', type: 'string', required: true },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ title: '' }).success).toBe(false);
-        expect(schema.safeParse({ title: 'ok' }).success).toBe(true);
-    });
-    it('campos opcionales aceptan vacío o ausente', () => {
-        const fields = [
-            { key: 'note', label: 'Nota', type: 'string' },
-            { key: 'qty', label: 'Cantidad', type: 'number' },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ note: '', qty: '' }).success).toBe(true);
-        expect(schema.safeParse({}).success).toBe(true);
-    });
-    it('valida email y url por type', () => {
-        const fields = [
-            { key: 'mail', label: 'Email', type: 'email', required: true },
-            { key: 'site', label: 'URL', type: 'url', required: true },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ mail: 'a@b.co', site: 'https://x.test' }).success).toBe(true);
-        expect(schema.safeParse({ mail: 'no-email', site: 'https://x.test' }).success).toBe(false);
-        expect(schema.safeParse({ mail: 'a@b.co', site: 'no-url' }).success).toBe(false);
-    });
-    it('regex inválida no rompe el build (silently skipped)', () => {
-        const fields = [
-            { key: 'x', label: 'X', type: 'string', required: true, validation: { regex: '[invalid(' } },
-        ];
-        expect(() => buildZodSchema(fields)).not.toThrow();
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ x: 'anything' }).success).toBe(true);
-    });
-    it('booleans requeridos exigen un valor explícito', () => {
-        const fields = [
-            { key: 'agree', label: 'Acepto', type: 'boolean', required: true },
-        ];
-        const schema = buildZodSchema(fields);
-        expect(schema.safeParse({ agree: true }).success).toBe(true);
-        expect(schema.safeParse({ agree: false }).success).toBe(true);
-        expect(schema.safeParse({}).success).toBe(false);
-    });
-});
-describe('resolveWidget', () => {
-    it('respeta widget explícito', () => {
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'string', widget: 'textarea' })).toBe('textarea');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'string', widget: 'richtext' })).toBe('richtext');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'string', widget: 'color' })).toBe('color');
-    });
-    it('cae al inferido por type cuando widget no está', () => {
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'textarea' })).toBe('textarea');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'select' })).toBe('select');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'boolean' })).toBe('switch');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'number' })).toBe('number');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'date' })).toBe('date');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'string' })).toBe('text');
-        expect(resolveWidget({ key: 'k', label: 'L', type: 'email' })).toBe('text');
-    });
-});

package/dist/__tests__/dynamic-relation.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dynamic-relation.test.d.ts.map

package/dist/__tests__/dynamic-relation.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dynamic-relation.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/dynamic-relation.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/dynamic-relation.test.js

@@ -1,228 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildCreatePayload, buildPivotAttachPayload, buildPivotRowIndex, buildRelationFilterParams, deriveRelationFormFields, diffSelection, extractSelectedTargetIds, pickOptionLabel, relationRowKey, } from '../dynamic-relation-helpers';
-describe('buildRelationFilterParams', () => {
-    it('produce el filtro f_<fk>=eq:<id> con string parentId', () => {
-        expect(buildRelationFilterParams('invoice_id', 'inv_42')).toEqual({
-            f_invoice_id: 'eq:inv_42',
-        });
-    });
-    it('coerce parentId numérico a string en el query', () => {
-        expect(buildRelationFilterParams('invoice_id', 42)).toEqual({
-            f_invoice_id: 'eq:42',
-        });
-    });
-    it('rechaza foreignKey vacío', () => {
-        expect(() => buildRelationFilterParams('', 'x')).toThrow(/foreignKey/);
-    });
-    it('rechaza parentId vacío / null / undefined', () => {
-        expect(() => buildRelationFilterParams('invoice_id', '')).toThrow(/parentId/);
-        // @ts-expect-error testing runtime guard
-        expect(() => buildRelationFilterParams('invoice_id', null)).toThrow(/parentId/);
-        // @ts-expect-error testing runtime guard
-        expect(() => buildRelationFilterParams('invoice_id', undefined)).toThrow(/parentId/);
-    });
-});
-describe('buildCreatePayload', () => {
-    it('inyecta el foreign key sobre los valores del form', () => {
-        const payload = buildCreatePayload('invoice_id', 'inv_42', { qty: 3, sku: 'A' });
-        expect(payload).toEqual({ qty: 3, sku: 'A', invoice_id: 'inv_42' });
-    });
-    it('el foreign key sobreescribe lo que venga del form', () => {
-        const payload = buildCreatePayload('invoice_id', 'inv_42', { invoice_id: 'inv_OTHER', qty: 1 });
-        expect(payload.invoice_id).toBe('inv_42');
-    });
-    it('preserva el parentId numérico tal cual', () => {
-        const payload = buildCreatePayload('invoice_id', 7, { qty: 1 });
-        expect(payload.invoice_id).toBe(7);
-    });
-    it('rechaza foreignKey vacío', () => {
-        expect(() => buildCreatePayload('', 'x', {})).toThrow(/foreignKey/);
-    });
-});
-describe('deriveRelationFormFields', () => {
-    const baseMeta = {
-        columns: [
-            { key: 'id', label: 'ID', type: 'text', sortable: true, filterable: false, hidden: true },
-            { key: 'invoice_id', label: 'Factura', type: 'text', sortable: false, filterable: false },
-            { key: 'sku', label: 'SKU', type: 'text', sortable: true, filterable: true },
-            { key: 'qty', label: 'Cantidad', type: 'number', sortable: true, filterable: false },
-            { key: 'taxable', label: 'Aplica IVA', type: 'boolean', sortable: false, filterable: false },
-            { key: 'category', label: 'Categoría', type: 'select', sortable: false, filterable: true, options: [
-                    { value: 'a', label: 'A' }, { value: 'b', label: 'B' },
-                ] },
-        ],
-    };
-    it('omite la foreign key porque está fija al parentId', () => {
-        const fields = deriveRelationFormFields(baseMeta, 'invoice_id');
-        expect(fields.find(f => f.key === 'invoice_id')).toBeUndefined();
-    });
-    it('omite columnas marcadas hidden', () => {
-        const fields = deriveRelationFormFields(baseMeta, 'invoice_id');
-        expect(fields.find(f => f.key === 'id')).toBeUndefined();
-    });
-    it('mapea types de ColumnDefinition al ActionFieldDef.type', () => {
-        const fields = deriveRelationFormFields(baseMeta, 'invoice_id');
-        const byKey = Object.fromEntries(fields.map(f => [f.key, f]));
-        expect(byKey['sku']?.type).toBe('string');
-        expect(byKey['qty']?.type).toBe('number');
-        expect(byKey['taxable']?.type).toBe('boolean');
-        expect(byKey['category']?.type).toBe('select');
-    });
-    it('propaga options con value coerced a string', () => {
-        const fields = deriveRelationFormFields(baseMeta, 'invoice_id');
-        const cat = fields.find(f => f.key === 'category');
-        expect(cat?.options).toEqual([
-            { value: 'a', label: 'A' },
-            { value: 'b', label: 'B' },
-        ]);
-    });
-    it('devuelve [] cuando no hay metadata', () => {
-        expect(deriveRelationFormFields(null, 'invoice_id')).toEqual([]);
-        expect(deriveRelationFormFields(undefined, 'invoice_id')).toEqual([]);
-        expect(deriveRelationFormFields({ columns: [] }, 'invoice_id')).toEqual([]);
-    });
-});
-describe('relationRowKey', () => {
-    it('usa row.id como key cuando existe', () => {
-        expect(relationRowKey({ id: 'abc' }, 0, 'invoice_id')).toBe('abc');
-        expect(relationRowKey({ id: 7 }, 5, 'invoice_id')).toBe('7');
-    });
-    it('cae a synthetic key cuando id falta o es vacío', () => {
-        expect(relationRowKey({}, 2, 'invoice_id')).toBe('__rel-invoice_id-2');
-        expect(relationRowKey({ id: '' }, 3, 'invoice_id')).toBe('__rel-invoice_id-3');
-        expect(relationRowKey({ id: null }, 1, 'invoice_id')).toBe('__rel-invoice_id-1');
-        expect(relationRowKey(undefined, 0, 'invoice_id')).toBe('__rel-invoice_id-0');
-    });
-});
-// ---------------------------------------------------------------------------
-// many_to_many helpers
-// ---------------------------------------------------------------------------
-describe('buildPivotAttachPayload', () => {
-    it('produce el body con los dos FKs fijos', () => {
-        const body = buildPivotAttachPayload('org_id', 'org_1', 'user_id', 'user_42');
-        expect(body).toEqual({ org_id: 'org_1', user_id: 'user_42' });
-    });
-    it('mezcla campos extra del pivot sin pisar los FKs', () => {
-        const body = buildPivotAttachPayload('org_id', 1, 'user_id', 2, {
-            role: 'owner',
-            org_id: 'evil',
-            user_id: 'evil',
-        });
-        expect(body.org_id).toBe(1);
-        expect(body.user_id).toBe(2);
-        expect(body.role).toBe('owner');
-    });
-    it('rechaza foreignKey / referencesKey vacíos', () => {
-        expect(() => buildPivotAttachPayload('', 'p', 'r', 't')).toThrow(/foreignKey/);
-        expect(() => buildPivotAttachPayload('f', 'p', '', 't')).toThrow(/referencesKey/);
-    });
-    it('rechaza parentId / targetId vacíos', () => {
-        expect(() => buildPivotAttachPayload('f', '', 'r', 't')).toThrow(/parentId/);
-        expect(() => buildPivotAttachPayload('f', 'p', 'r', '')).toThrow(/targetId/);
-        // @ts-expect-error testing runtime guard
-        expect(() => buildPivotAttachPayload('f', 'p', 'r', null)).toThrow(/targetId/);
-    });
-});
-describe('extractSelectedTargetIds', () => {
-    it('mapea pivot rows al set de target ids como strings', () => {
-        const ids = extractSelectedTargetIds([
-            { id: 1, org_id: 'org_1', user_id: 'u_1' },
-            { id: 2, org_id: 'org_1', user_id: 7 },
-        ], 'user_id');
-        expect(ids).toEqual(['u_1', '7']);
-    });
-    it('omite filas sin valor en el referencesKey', () => {
-        const ids = extractSelectedTargetIds([
-            { id: 1, user_id: 'u_1' },
-            { id: 2, user_id: null },
-            { id: 3, user_id: '' },
-            { id: 4 },
-        ], 'user_id');
-        expect(ids).toEqual(['u_1']);
-    });
-    it('devuelve [] cuando no hay rows o referencesKey', () => {
-        expect(extractSelectedTargetIds(null, 'user_id')).toEqual([]);
-        expect(extractSelectedTargetIds(undefined, 'user_id')).toEqual([]);
-        expect(extractSelectedTargetIds([{ user_id: 'x' }], '')).toEqual([]);
-    });
-});
-describe('buildPivotRowIndex', () => {
-    it('mapea targetId -> pivotRowId', () => {
-        const idx = buildPivotRowIndex([
-            { id: 'p1', user_id: 'u_1' },
-            { id: 'p2', user_id: 7 },
-        ], 'user_id');
-        expect(idx.get('u_1')).toBe('p1');
-        expect(idx.get('7')).toBe('p2');
-    });
-    it('omite filas sin id pivot o sin target', () => {
-        const idx = buildPivotRowIndex([
-            { id: 'p1', user_id: 'u_1' },
-            { user_id: 'u_2' },
-            { id: 'p3' },
-            { id: 'p4', user_id: null },
-        ], 'user_id');
-        expect(Array.from(idx.keys())).toEqual(['u_1']);
-    });
-    it('última fila gana cuando hay duplicados', () => {
-        const idx = buildPivotRowIndex([
-            { id: 'p1', user_id: 'u_1' },
-            { id: 'p2', user_id: 'u_1' },
-        ], 'user_id');
-        expect(idx.get('u_1')).toBe('p2');
-    });
-});
-describe('diffSelection', () => {
-    it('detecta toAdd y toRemove respecto al estado previo', () => {
-        const { toAdd, toRemove } = diffSelection(['a', 'b', 'c'], ['b', 'c', 'd']);
-        expect(toAdd).toEqual(['d']);
-        expect(toRemove).toEqual(['a']);
-    });
-    it('preserva el orden de aparición en next/prev', () => {
-        const { toAdd, toRemove } = diffSelection(['a', 'b'], ['c', 'a', 'd']);
-        expect(toAdd).toEqual(['c', 'd']);
-        expect(toRemove).toEqual(['b']);
-    });
-    it('devuelve arrays vacíos cuando no cambia nada', () => {
-        const { toAdd, toRemove } = diffSelection(['a', 'b'], ['b', 'a']);
-        expect(toAdd).toEqual([]);
-        expect(toRemove).toEqual([]);
-    });
-    it('caso vacío -> next agrega todo', () => {
-        const { toAdd, toRemove } = diffSelection([], ['a', 'b']);
-        expect(toAdd).toEqual(['a', 'b']);
-        expect(toRemove).toEqual([]);
-    });
-    it('caso prev -> [] remueve todo', () => {
-        const { toAdd, toRemove } = diffSelection(['a', 'b'], []);
-        expect(toAdd).toEqual([]);
-        expect(toRemove).toEqual(['a', 'b']);
-    });
-});
-describe('pickOptionLabel', () => {
-    const cols = [
-        { key: 'id', label: 'ID', type: 'text', sortable: false, filterable: false, hidden: true },
-        { key: 'name', label: 'Nombre', type: 'text', sortable: true, filterable: true },
-        { key: 'email', label: 'Email', type: 'text', sortable: false, filterable: true },
-    ];
-    it('respeta displayKey cuando existe en la fila', () => {
-        expect(pickOptionLabel({ id: 1, name: 'Alice', email: 'a@x' }, 'email', cols)).toBe('a@x');
-    });
-    it('cae al primer column no-id no-hidden cuando displayKey falta', () => {
-        expect(pickOptionLabel({ id: 1, name: 'Alice', email: 'a@x' }, undefined, cols)).toBe('Alice');
-    });
-    it('salta valores nulos / vacíos al inferir', () => {
-        expect(pickOptionLabel({ id: 1, name: '', email: 'a@x' }, undefined, cols)).toBe('a@x');
-    });
-    it('cae a row.id cuando no hay match en columns', () => {
-        expect(pickOptionLabel({ id: 7 }, undefined, cols)).toBe('7');
-        expect(pickOptionLabel({ id: 7 }, undefined, undefined)).toBe('7');
-    });
-    it('devuelve "—" cuando no hay nada usable', () => {
-        expect(pickOptionLabel(null, undefined, cols)).toBe('—');
-        expect(pickOptionLabel({}, undefined, cols)).toBe('—');
-    });
-    it('ignora valores object al inferir', () => {
-        expect(pickOptionLabel({ id: 1, name: { nested: true }, email: 'a@x' }, undefined, cols)).toBe('a@x');
-    });
-});