@object-ui/app-shell 6.1.0 → 6.2.1

package/dist/views/metadata-admin/anchors.js

@@ -0,0 +1,229 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * Built-in anchor relationships for the Related tab.
+ *
+ * Each entry tells the metadata-admin engine "items of type X belong to
+ * (are anchored at) items of type Y when this predicate matches". The
+ * Related panel on the parent's edit page uses this registry to decide
+ * which `client.list(type)` calls to make and how to group the results.
+ *
+ * Adding a new relationship is intentionally a one-liner — declare it
+ * here (or in your own plugin's bootstrap) and the UI picks it up with
+ * no further wiring. Predicates are kept tiny because they run client-
+ * side over every item returned from `list()`.
+ *
+ * Why not parse the schema and infer this? Some types nest the anchor
+ * deep in `data.object` or `list.data.object`; some types live on the
+ * parent (e.g. `fields` is embedded inside the object item itself).
+ * Hand-rolled declarations are clearer than schema-walking heuristics.
+ */
+import { registerMetadataResource, anchorByField } from './registry';
+export function registerBuiltinAnchors() {
+    // ── EMBEDDED: items stored inside the object body itself ──────────
+    //
+    // Fields, indexes, and embedded validations don't have a top-level
+    // metadata type; they live under `object.fields`, `object.indexes[]`,
+    // `object.validations[]`. We surface them with `source: 'embedded'`
+    // so the Related panel can list them without a separate API call.
+    //
+    // `fields` is stored as a NAME-KEYED MAP (`{ email: {...}, name: {...} }`)
+    // — not an array — so we adapt it into an array carrying the key as
+    // `name` for the panel to render.
+    registerMetadataResource({
+        type: '__object_field',
+        label: 'Field',
+        anchors: [{
+                anchorType: 'object',
+                source: 'embedded',
+                extract: (parent) => mapOrArrayToList(parent.fields),
+                groupLabel: 'Fields',
+                order: 5,
+            }],
+    });
+    registerMetadataResource({
+        type: '__object_index',
+        label: 'Index',
+        anchors: [{
+                anchorType: 'object',
+                source: 'embedded',
+                extract: (parent) => {
+                    const raw = parent.indexes;
+                    if (!Array.isArray(raw))
+                        return [];
+                    // Indexes have no `name`; synthesise one from their column list.
+                    return raw.map((idx, i) => {
+                        const fields = Array.isArray(idx.fields) ? idx.fields.join(',') : '';
+                        const synthesised = fields ? `idx_${fields}` : `index_${i}`;
+                        return { name: synthesised, ...idx };
+                    });
+                },
+                groupLabel: 'Indexes',
+                order: 10,
+            }],
+    });
+    registerMetadataResource({
+        type: '__object_validation',
+        label: 'Embedded validation',
+        anchors: [{
+                anchorType: 'object',
+                source: 'embedded',
+                extract: (parent) => mapOrArrayToList(parent.validations),
+                groupLabel: 'Embedded Validations',
+                order: 15,
+            }],
+    });
+    // ── LIST: standalone child metadata types ─────────────────────────
+    // hook.object → object (beforeInsert / afterUpdate / …)
+    registerMetadataResource({
+        type: 'hook',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField('object'),
+                groupLabel: 'Hooks',
+                order: 20,
+            }],
+    });
+    // approval.object → object (approval processes targeting this object)
+    registerMetadataResource({
+        type: 'approval',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField('object'),
+                groupLabel: 'Approval Processes',
+                order: 70,
+            }],
+    });
+    // page.object → object (auto-generated record pages, etc.)
+    registerMetadataResource({
+        type: 'page',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField('object'),
+                groupLabel: 'Pages',
+                order: 40,
+            }],
+    });
+    // view binds to an object via data.object (list view / form view variants)
+    registerMetadataResource({
+        type: 'view',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField([
+                    'data.object',
+                    'list.data.object',
+                    'form.data.object',
+                    'object',
+                ]),
+                groupLabel: 'Views',
+                order: 30,
+            }],
+    });
+    // flow / workflow may reference an object at the root or under `on`
+    registerMetadataResource({
+        type: 'flow',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField(['object', 'on.object', 'trigger.object']),
+                groupLabel: 'Flows',
+                order: 50,
+            }],
+    });
+    registerMetadataResource({
+        type: 'workflow',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField(['object', 'on.object']),
+                groupLabel: 'Workflow Rules',
+                order: 51,
+            }],
+    });
+    // trigger.object → object (low-level DB-style triggers)
+    registerMetadataResource({
+        type: 'trigger',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField(['object', 'on.object']),
+                groupLabel: 'Triggers',
+                order: 52,
+            }],
+    });
+    // validation: usually embedded in the object, but standalone variants
+    // do exist. Match anything whose `object` points back at us.
+    registerMetadataResource({
+        type: 'validation',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField('object'),
+                groupLabel: 'Validations',
+                order: 25,
+            }],
+    });
+    // permission has a sparse object-keyed map under `objects`. Match by
+    // membership of the parent name in that map.
+    registerMetadataResource({
+        type: 'permission',
+        anchors: [{
+                anchorType: 'object',
+                match: (item, name) => {
+                    const objs = item?.objects;
+                    return !!objs && typeof objs === 'object' && name in objs;
+                },
+                groupLabel: 'Permissions',
+                order: 60,
+            }],
+    });
+    // action — both record-scoped and object-scoped actions live here.
+    // Schemas vary, so accept any of the three common shapes.
+    registerMetadataResource({
+        type: 'action',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField([
+                    'object',
+                    'target.object',
+                    'on.object',
+                ]),
+                groupLabel: 'Actions',
+                order: 55,
+            }],
+    });
+    // dashboard / report — surface ones bound to a specific object.
+    // Many will not have an explicit anchor; those simply don't appear.
+    registerMetadataResource({
+        type: 'dashboard',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField(['object', 'data.object']),
+                groupLabel: 'Dashboards',
+                order: 80,
+            }],
+    });
+    registerMetadataResource({
+        type: 'report',
+        anchors: [{
+                anchorType: 'object',
+                match: anchorByField(['object', 'data.object']),
+                groupLabel: 'Reports',
+                order: 81,
+            }],
+    });
+}
+/**
+ * Coerce an embedded "collection" into a list of `{ name, …rest }`.
+ *
+ * ObjectStack stores some embedded collections as name-keyed maps
+ * (`object.fields`) and others as arrays (`object.indexes`). Both want
+ * to render the same way in Related; this helper papers over the gap
+ * by injecting the map key as `name` when needed.
+ */
+function mapOrArrayToList(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === 'object') {
+        return Object.entries(raw).map(([k, v]) => {
+            const body = v && typeof v === 'object' ? v : {};
+            return { name: k, ...body };
+        });
+    }
+    return [];
+}

package/dist/views/metadata-admin/default-schemas.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Register fallback schemas for every writable type. Idempotent — uses
+ * `registerMetadataResource` so any prior registration (e.g. a bespoke
+ * EditPage from PermissionMatrixEditor) is merged via the engine.
+ */
+export declare function registerDefaultMetadataSchemas(): void;

package/dist/views/metadata-admin/default-schemas.js

@@ -0,0 +1,207 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+/**
+ * default-schemas — minimal JSONSchemas used by SchemaForm when the
+ * framework's `/meta/types` registry row doesn't carry a `schema` field
+ * (i.e. for every type today — full Zod→JSONSchema generation in the
+ * framework is a deferred milestone).
+ *
+ * These schemas cover the universal metadata header (name/label/
+ * description/scope) plus the small set of per-type "obvious" fields
+ * users expect on day one. Anything that doesn't fit here can still be
+ * edited via the raw JSON escape hatch — the schema is intentionally
+ * lax (no `additionalProperties: false`) so unknown payload keys round-
+ * trip untouched.
+ *
+ * When the framework starts emitting JSONSchemas in the registry, this
+ * file becomes a no-op (SchemaForm receives the real schema and ignores
+ * `defaultSchema`).
+ */
+import { registerMetadataResource } from './registry';
+/** Shared header fields every metadata item has. */
+const headerProps = {
+    name: {
+        type: 'string',
+        title: 'Name',
+        description: 'Machine name. snake_case, used as the URL path and DB key.',
+        pattern: '^[a-z_][a-z0-9_]*$',
+    },
+    label: {
+        type: 'string',
+        title: 'Label',
+        description: 'Human-readable display name.',
+    },
+    description: {
+        type: 'string',
+        title: 'Description',
+        format: 'multiline',
+    },
+};
+/** Per-type fallback schemas. */
+const SCHEMAS = {
+    role: {
+        type: 'object',
+        title: 'Role',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            level: {
+                type: 'string',
+                title: 'Level',
+                description: 'Coarse seniority tier (used by UI / sort order).',
+                enum: ['member', 'lead', 'manager', 'director', 'executive', 'admin'],
+            },
+            parentRole: {
+                type: 'string',
+                title: 'Parent Role',
+                description: 'Optional parent role name for hierarchy.',
+            },
+        },
+    },
+    profile: {
+        type: 'object',
+        title: 'Profile',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            isProfile: { type: 'boolean', title: 'Is profile', description: 'Profiles are mutually exclusive (one per user).' },
+            objects: {
+                type: 'object',
+                title: 'Object Permissions',
+                description: 'Edit this via the Permission Matrix tab for a row-by-row UI.',
+            },
+        },
+    },
+    permission: {
+        type: 'object',
+        title: 'Permission Set',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            isProfile: { type: 'boolean', title: 'Is profile' },
+            objects: { type: 'object', title: 'Object Permissions' },
+            fields: { type: 'object', title: 'Field Permissions' },
+        },
+    },
+    translation: {
+        type: 'object',
+        title: 'Translation Bundle',
+        required: ['name'],
+        properties: {
+            name: { ...headerProps.name, description: 'Bundle id (e.g. zh_CN, en_US, package-locale).' },
+            label: headerProps.label,
+            description: headerProps.description,
+            locale: {
+                type: 'string',
+                title: 'Locale',
+                description: 'BCP-47 tag, e.g. en, zh-Hans, ja-JP.',
+            },
+            strings: {
+                type: 'object',
+                title: 'Strings',
+                description: 'Key → translated string map.',
+            },
+        },
+    },
+    tool: {
+        type: 'object',
+        title: 'AI Tool',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            kind: {
+                type: 'string',
+                title: 'Kind',
+                enum: ['function', 'http', 'mcp'],
+            },
+            inputSchema: { type: 'object', title: 'Input Schema (JSON Schema)' },
+            outputSchema: { type: 'object', title: 'Output Schema (JSON Schema)' },
+        },
+    },
+    skill: {
+        type: 'object',
+        title: 'AI Skill',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            instructions: { type: 'string', title: 'Instructions', format: 'multiline' },
+            tools: { type: 'array', title: 'Tools', items: { type: 'string' } },
+        },
+    },
+    app: {
+        type: 'object',
+        title: 'Application',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            icon: { type: 'string', title: 'Icon' },
+            navigation: { type: 'array', title: 'Navigation', items: { type: 'object' } },
+        },
+    },
+    page: {
+        type: 'object',
+        title: 'Page',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            route: { type: 'string', title: 'Route', description: 'URL path under the app.' },
+            layout: { type: 'string', title: 'Layout' },
+        },
+    },
+    view: {
+        type: 'object',
+        title: 'View',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            type: {
+                type: 'string',
+                title: 'View Type',
+                enum: ['grid', 'kanban', 'calendar', 'gantt', 'simple', 'tabbed', 'wizard', 'split', 'drawer', 'modal'],
+            },
+        },
+    },
+    dashboard: {
+        type: 'object',
+        title: 'Dashboard',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            widgets: { type: 'array', title: 'Widgets', items: { type: 'object' } },
+        },
+    },
+    report: {
+        type: 'object',
+        title: 'Report',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            object: { type: 'string', title: 'Object' },
+            filters: { type: 'array', title: 'Filters', items: { type: 'object' } },
+        },
+    },
+    email_template: {
+        type: 'object',
+        title: 'Email Template',
+        required: ['name'],
+        properties: {
+            ...headerProps,
+            subject: { type: 'string', title: 'Subject' },
+            body: { type: 'string', title: 'Body (HTML / text)', format: 'multiline' },
+            from: { type: 'string', title: 'From address' },
+        },
+    },
+};
+/**
+ * Register fallback schemas for every writable type. Idempotent — uses
+ * `registerMetadataResource` so any prior registration (e.g. a bespoke
+ * EditPage from PermissionMatrixEditor) is merged via the engine.
+ */
+export function registerDefaultMetadataSchemas() {
+    for (const [type, schema] of Object.entries(SCHEMAS)) {
+        registerMetadataResource({
+            type,
+            defaultSchema: schema,
+            fieldOrder: ['name', 'label', 'description'],
+        });
+    }
+}

package/dist/views/metadata-admin/i18n.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Metadata admin i18n bundle (Phase 3f).
+ *
+ * Lightweight static label table for the 27 built-in metadata types,
+ * plus a tiny `t()` helper for engine UI strings.
+ *
+ * Why not i18next? The engine already consumes `label` from the
+ * server's `/meta/types` response (which is sourced from
+ * `DEFAULT_METADATA_TYPE_REGISTRY`). This bundle exists as a fallback
+ * for environments without translation bundles configured, and as the
+ * single source of truth for Chinese labels until the platform's
+ * `setup.translation.ts` ships zh-CN coverage.
+ *
+ * Usage:
+ *   import { translateMetadataType, t } from './i18n';
+ *   translateMetadataType('view', 'zh-CN')  // → '视图'
+ *   t('engine.directory.title', 'zh-CN')    // → '元数据'
+ *
+ * The DirectoryPage / PageShell call these to localise headings when
+ * the consumer hasn't wired the global i18n provider.
+ */
+export type SupportedLocale = 'en-US' | 'zh-CN';
+export declare function translateMetadataType(type: string, locale?: SupportedLocale | string, fallback?: string): string;
+export declare function translateMetadataDomain(domain: string, locale?: SupportedLocale | string): string;
+export declare function t(key: string, locale?: SupportedLocale | string): string;
+/**
+ * Format a translated string with `{token}` placeholders.
+ *
+ *   tFormat('engine.directory.description', 'zh-CN', { count: 28, writable: 4 })
+ */
+export declare function tFormat(key: string, locale: SupportedLocale | string | undefined, vars: Record<string, string | number>): string;
+/** Returns the locale string most browsers report (matches navigator.language). */
+export declare function detectLocale(): SupportedLocale;