@vertesia/studio-utils 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261004.085740Z

package/src/prompts/validate.test.ts

@@ -1,309 +0,0 @@
-import type { JSONSchema } from '@vertesia/common';
-import { TemplateType } from '@vertesia/common';
-import { describe, expect, it } from 'vitest';
-import { type PromptValidationIssue, validatePrompt } from './validate.js';
-
-function findIssue(
-    issues: PromptValidationIssue[],
-    type: PromptValidationIssue['type'],
-    variable?: string,
-): PromptValidationIssue | undefined {
-    return issues.find((i) => i.type === type && (variable === undefined || i.variable === variable));
-}
-
-const schema = (properties: Record<string, JSONSchema>, required?: string[]): JSONSchema => ({
-    type: 'object',
-    properties,
-    ...(required ? { required } : {}),
-});
-
-describe('validatePrompt — text (no validation)', () => {
-    it('returns no issues for plain text content regardless of schema', () => {
-        const r = validatePrompt({
-            content: 'Hello, this is just text. {{not a template tag}}',
-            contentType: TemplateType.text,
-            inputSchema: schema({ unused: { type: 'string' } }),
-        });
-        expect(r.error_count).toBe(0);
-        expect(r.warning_count).toBe(0);
-        expect(r.issues).toHaveLength(0);
-    });
-});
-
-describe('validatePrompt — handlebars', () => {
-    describe('undeclared_template_variable (error)', () => {
-        it('flags a top-level variable that is not in the schema', () => {
-            const r = validatePrompt({
-                content: 'Summarize this document: {{document}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({}),
-            });
-            const issue = findIssue(r.issues, 'undeclared_template_variable', 'document');
-            expect(issue).toBeDefined();
-            expect(issue?.severity).toBe('error');
-            expect(r.error_count).toBeGreaterThanOrEqual(1);
-        });
-
-        it('flags multiple undeclared variables independently', () => {
-            const r = validatePrompt({
-                content: 'Hi {{name}}, your role is {{role}} and dept is {{dept}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({ name: { type: 'string' } }),
-            });
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'role')).toBeDefined();
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'dept')).toBeDefined();
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'name')).toBeUndefined();
-        });
-
-        it('flags the root variable when the template uses dotted access', () => {
-            // Handlebars `{{user.name}}` references the top-level `user` — the schema must declare `user`.
-            const r = validatePrompt({
-                content: 'User: {{user.name}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({}),
-            });
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'user')).toBeDefined();
-        });
-
-        it('treats no schema as schema with no properties', () => {
-            const r = validatePrompt({
-                content: 'Hello {{name}}',
-                contentType: TemplateType.handlebars,
-            });
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'name')).toBeDefined();
-        });
-    });
-
-    describe('unused_schema_variable (warning)', () => {
-        it('flags a schema property that the template never references', () => {
-            const r = validatePrompt({
-                content: 'Hello {{name}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({
-                    name: { type: 'string' },
-                    extra: { type: 'string' },
-                }),
-            });
-            const issue = findIssue(r.issues, 'unused_schema_variable', 'extra');
-            expect(issue).toBeDefined();
-            expect(issue?.severity).toBe('warning');
-            expect(r.warning_count).toBeGreaterThanOrEqual(1);
-        });
-
-        it('does not block validation — only errors do', () => {
-            const r = validatePrompt({
-                content: 'Hello {{name}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({
-                    name: { type: 'string' },
-                    unused: { type: 'string' },
-                }),
-            });
-            expect(r.error_count).toBe(0);
-            expect(r.warning_count).toBe(1);
-        });
-    });
-
-    describe('handlebars_render_error (error)', () => {
-        it('flags a syntax error in the template', () => {
-            const r = validatePrompt({
-                // Unclosed mustache → handlebars parse error
-                content: 'Hello {{name',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({ name: { type: 'string' } }),
-            });
-            expect(findIssue(r.issues, 'handlebars_render_error')).toBeDefined();
-            expect(r.error_count).toBeGreaterThanOrEqual(1);
-        });
-
-        it('flags an unregistered helper call', () => {
-            const r = validatePrompt({
-                content: 'Tactics: {{join mitre_tactics ", "}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({ mitre_tactics: { type: 'array', items: { type: 'string' } } }),
-            });
-
-            const issue = findIssue(r.issues, 'handlebars_render_error');
-            expect(issue).toBeDefined();
-            expect(issue?.message).toContain('Missing helper: "join"');
-        });
-    });
-
-    describe('happy path', () => {
-        it('returns zero issues when every template variable is declared and every declared variable is used', () => {
-            const r = validatePrompt({
-                content: 'Hello {{name}}, please summarize: {{document}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema(
-                    {
-                        name: { type: 'string' },
-                        document: { type: 'string' },
-                    },
-                    ['name', 'document'],
-                ),
-            });
-            expect(r.error_count).toBe(0);
-            expect(r.warning_count).toBe(0);
-            expect(r.issues).toHaveLength(0);
-        });
-
-        it('accepts handlebars block helpers (#if/#each) on declared variables', () => {
-            const r = validatePrompt({
-                content: '{{#if items}}Items:{{#each items}}- {{this}}\n{{/each}}{{/if}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({ items: { type: 'array', items: { type: 'string' } } }),
-            });
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'items')).toBeUndefined();
-            expect(r.error_count).toBe(0);
-        });
-    });
-
-    describe('combined errors + warnings', () => {
-        it('reports both kinds in one pass and counts them correctly', () => {
-            const r = validatePrompt({
-                content: 'Hi {{name}}, document: {{document}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({
-                    name: { type: 'string' },
-                    extra: { type: 'string' }, // unused → warning
-                    // document missing → error
-                }),
-            });
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'document')).toBeDefined();
-            expect(findIssue(r.issues, 'unused_schema_variable', 'extra')).toBeDefined();
-            expect(r.error_count).toBe(1);
-            expect(r.warning_count).toBe(1);
-            expect(r.issues.length).toBe(2);
-        });
-    });
-
-    describe('ordering and independence of error sources', () => {
-        // Handlebars is non-strict — `{{undeclared}}` renders as empty string, NOT an exception.
-        // So an undeclared variable does not cause a render error; only one error is reported.
-        it('reports undeclared_template_variable only (render does not echo it in non-strict Handlebars)', () => {
-            const r = validatePrompt({
-                content: 'Hello {{undefined_var}}',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({}),
-            });
-            expect(findIssue(r.issues, 'undeclared_template_variable', 'undefined_var')).toBeDefined();
-            expect(findIssue(r.issues, 'handlebars_render_error')).toBeUndefined();
-            expect(r.error_count).toBe(1);
-        });
-
-        // When the template has both an undeclared variable AND a real parse error,
-        // we must surface both — and the variable error must appear first in the list
-        // so the LLM/user sees the precise reason before the generic render error.
-        it('reports BOTH undeclared_template_variable and handlebars_render_error, vars first', () => {
-            const r = validatePrompt({
-                // {{name has no closing brace → parse error. extractHandlebarsVariables fails
-                // silently and returns an empty set, so no undeclared error is raised by
-                // step 1 here — but the rendering step catches the parse failure.
-                content: 'Hello {{undefined_var}} and {{name',
-                contentType: TemplateType.handlebars,
-                inputSchema: schema({}),
-            });
-            // The renderer reports the parse problem; the var-extractor couldn't even parse the
-            // template, so it returned no usedVars and we cannot detect the undeclared var here.
-            // The contract is "both kinds are independent and both reported when applicable".
-            expect(findIssue(r.issues, 'handlebars_render_error')).toBeDefined();
-        });
-    });
-});
-
-describe('validatePrompt — jst', () => {
-    it('happy path: identifier referenced and declared', () => {
-        const r = validatePrompt({
-            content: 'return `hello ${name}`;',
-            contentType: TemplateType.jst,
-            inputSchema: schema({ name: { type: 'string' } }, ['name']),
-        });
-        expect(r.error_count).toBe(0);
-        expect(r.warning_count).toBe(0);
-    });
-
-    it('flags undeclared identifier as error', () => {
-        const r = validatePrompt({
-            content: 'return `hello ${name}`;',
-            contentType: TemplateType.jst,
-            inputSchema: schema({}),
-        });
-        expect(findIssue(r.issues, 'undeclared_template_variable', 'name')).toBeDefined();
-        expect(r.error_count).toBeGreaterThanOrEqual(1);
-    });
-
-    it('flags declared-but-unused as warning', () => {
-        const r = validatePrompt({
-            content: 'return `hello ${name}`;',
-            contentType: TemplateType.jst,
-            inputSchema: schema({
-                name: { type: 'string' },
-                unused: { type: 'string' },
-            }),
-        });
-        const issue = findIssue(r.issues, 'unused_schema_variable', 'unused');
-        expect(issue).toBeDefined();
-        expect(issue?.severity).toBe('warning');
-    });
-
-    it('does not flag locally-bound variables as undeclared', () => {
-        const r = validatePrompt({
-            content: 'const greeting = `hello ${name}`; return greeting;',
-            contentType: TemplateType.jst,
-            inputSchema: schema({ name: { type: 'string' } }, ['name']),
-        });
-        expect(findIssue(r.issues, 'undeclared_template_variable', 'greeting')).toBeUndefined();
-        expect(r.error_count).toBe(0);
-    });
-
-    it('does not flag jst auto-globals (_, Array, Set)', () => {
-        const r = validatePrompt({
-            content: 'return _.stringify({ count: Array.isArray(items) ? items.length : 0 });',
-            contentType: TemplateType.jst,
-            inputSchema: schema({ items: { type: 'array', items: { type: 'string' } } }, ['items']),
-        });
-        expect(findIssue(r.issues, 'undeclared_template_variable', '_')).toBeUndefined();
-        expect(findIssue(r.issues, 'undeclared_template_variable', 'Array')).toBeUndefined();
-    });
-
-    it('flags unsafe constructs (with) as jst_unsafe_construct', () => {
-        const r = validatePrompt({
-            content: 'with (foo) { return bar; }',
-            contentType: TemplateType.jst,
-            inputSchema: schema({ foo: { type: 'object' }, bar: { type: 'string' } }, ['foo', 'bar']),
-        });
-        expect(findIssue(r.issues, 'jst_unsafe_construct')).toBeDefined();
-    });
-
-    it('flags for-loops as jst_unsafe_construct', () => {
-        const r = validatePrompt({
-            content: 'for (let i = 0; i < items.length; i++) { return items[i]; } return null;',
-            contentType: TemplateType.jst,
-            inputSchema: schema({ items: { type: 'array', items: { type: 'string' } } }, ['items']),
-        });
-        expect(findIssue(r.issues, 'jst_unsafe_construct')).toBeDefined();
-    });
-});
-
-describe('Handlebars runtime values', () => {
-    it('accepts the bare time helper with an empty schema', () => {
-        const result = validatePrompt({
-            content: '{{_now}}',
-            contentType: TemplateType.handlebars,
-            inputSchema: schema({}),
-        });
-        expect(result.error_count).toBe(0);
-    });
-
-    it.each(['{{this._now}}', '{{_now.foo}}'])('requires a declaration for explicit data path %s', (content) => {
-        const result = validatePrompt({ content, contentType: TemplateType.handlebars, inputSchema: schema({}) });
-        expect(findIssue(result.issues, 'undeclared_template_variable', '_now')).toBeDefined();
-    });
-
-    it('accepts the runtime model without accepting ordinary undeclared variables', () => {
-        const result = validatePrompt({ content: '{{_model}} {{customer}}', contentType: TemplateType.handlebars });
-        expect(findIssue(result.issues, 'undeclared_template_variable', '_model')).toBeUndefined();
-        expect(findIssue(result.issues, 'undeclared_template_variable', 'customer')).toBeDefined();
-        expect(validatePrompt({ content: '{{_model}}', contentType: TemplateType.handlebars }).error_count).toBe(0);
-    });
-});

package/src/roles/index.test.ts

@@ -1,221 +0,0 @@
-import { Permission, SystemRoles } from '@vertesia/common';
-import { describe, expect, it } from 'vitest';
-import { ContentRoleNames } from './content.js';
-import {
-    AbacRole,
-    getAllRoleNames,
-    getDelegablePermissionsForRole,
-    getPermissionsForRoles,
-    getRoleByName,
-    listAbacRolesForScope,
-    listRoles,
-    listRolesByDomain,
-    listSystemRoles,
-    Role,
-    RoleList,
-    SystemRole,
-} from './index.js';
-
-describe('getRoleByName', () => {
-    it('returns a system role by name', () => {
-        const role = getRoleByName(SystemRoles.owner);
-        expect(role).toBeInstanceOf(SystemRole);
-        expect(role.name).toBe('owner');
-        expect(role.domain).toBe('system');
-    });
-
-    it('returns an ABAC role by name', () => {
-        const role = getRoleByName(ContentRoleNames.content_reader);
-        expect(role).toBeInstanceOf(AbacRole);
-        expect(role.name).toBe('content:reader');
-        expect(role.domain).toBe('content');
-    });
-
-    it('throws on unknown role', () => {
-        expect(() => getRoleByName('not_a_real_role')).toThrow(/Role not_a_real_role not found/);
-    });
-
-    it('queries partitions in registration order — system first', () => {
-        // System partition is registered before content. Even if a future partition
-        // declared a role named 'owner', the system one would still win.
-        const role = getRoleByName(SystemRoles.owner);
-        expect(role.domain).toBe('system');
-    });
-});
-
-describe('listRoles', () => {
-    it('returns every role across all partitions', () => {
-        const roles = listRoles();
-        // 17 system roles + 3 content roles
-        expect(roles).toHaveLength(20);
-    });
-
-    it('lists system roles before content roles (partition registration order)', () => {
-        const roles = listRoles();
-        const systemCount = roles.filter((r) => r.domain === 'system').length;
-        const contentCount = roles.filter((r) => r.domain === 'content').length;
-        expect(systemCount).toBe(17);
-        expect(contentCount).toBe(3);
-
-        // First 17 are system, next 3 are content
-        for (let i = 0; i < 17; i++) expect(roles[i].domain).toBe('system');
-        for (let i = 17; i < 20; i++) expect(roles[i].domain).toBe('content');
-    });
-});
-
-describe('listRolesByDomain', () => {
-    it('returns only system roles for "system"', () => {
-        const roles = listRolesByDomain('system');
-        expect(roles).toHaveLength(17);
-        expect(roles.every((r) => r.domain === 'system')).toBe(true);
-    });
-
-    it('returns only content roles for "content"', () => {
-        const roles = listRolesByDomain('content');
-        expect(roles).toHaveLength(3);
-        expect(roles.every((r) => r.domain === 'content')).toBe(true);
-    });
-
-    it('returns empty for an unregistered domain', () => {
-        expect(listRolesByDomain('tasks')).toEqual([]);
-    });
-});
-
-describe('listSystemRoles', () => {
-    it('returns SystemRole instances', () => {
-        const roles = listSystemRoles();
-        expect(roles).toHaveLength(17);
-        expect(roles.every((r) => r instanceof SystemRole)).toBe(true);
-    });
-
-    it('excludes ABAC roles', () => {
-        const roles = listSystemRoles();
-        expect(roles.some((r) => r instanceof AbacRole)).toBe(false);
-    });
-});
-
-describe('listAbacRolesForScope', () => {
-    it('returns content roles for "document" scope', () => {
-        const roles = listAbacRolesForScope('document');
-        expect(roles).toHaveLength(3);
-        expect(roles.map((r) => r.name).sort()).toEqual(['content:manager', 'content:reader', 'content:writer']);
-    });
-
-    it('returns content roles for "collection" scope (same roles, applicableScopes covers both)', () => {
-        const roles = listAbacRolesForScope('collection');
-        expect(roles).toHaveLength(3);
-        expect(roles.every((r) => r.applicableScopes.includes('collection'))).toBe(true);
-    });
-
-    it('returns empty for "task" scope (no task partition registered)', () => {
-        expect(listAbacRolesForScope('task')).toEqual([]);
-    });
-
-    it('returns AbacRole instances only — no system roles bleed through', () => {
-        const roles = listAbacRolesForScope('document');
-        expect(roles.every((r) => r instanceof AbacRole)).toBe(true);
-    });
-});
-
-describe('getAllRoleNames', () => {
-    it('returns names of every registered role', () => {
-        const names = getAllRoleNames();
-        expect(names).toHaveLength(20);
-        expect(names).toContain('owner');
-        expect(names).toContain('content:reader');
-    });
-
-    it('produces a flat list suited for mongoose enum constraints', () => {
-        const names = getAllRoleNames();
-        expect(names.every((n) => typeof n === 'string')).toBe(true);
-    });
-});
-
-describe('getPermissionsForRoles', () => {
-    it('merges permissions across multiple roles, deduped', () => {
-        // content:reader: ['read']
-        // content:writer: ['read', 'write']
-        const merged = getPermissionsForRoles([ContentRoleNames.content_reader, ContentRoleNames.content_writer]);
-        expect(merged.sort()).toEqual(['read', 'write']);
-    });
-
-    it('returns system Permission values for system roles', () => {
-        const merged = getPermissionsForRoles([SystemRoles.reader]);
-        // reader role has: int_read, run_read, content_read + account_member (via OrgMemberRole)
-        expect(merged).toContain(Permission.int_read);
-        expect(merged).toContain(Permission.content_read);
-        expect(merged).toContain(Permission.account_member);
-    });
-});
-
-describe('getDelegablePermissionsForRole', () => {
-    it('returns system permission keys unchanged', () => {
-        expect(getDelegablePermissionsForRole(SystemRoles.reader)).toContain(Permission.content_read);
-    });
-
-    it('qualifies ABAC verbs with their role domain', () => {
-        expect(getDelegablePermissionsForRole(ContentRoleNames.content_manager).sort()).toEqual([
-            Permission.content_delete,
-            Permission.content_read,
-            Permission.content_write,
-        ]);
-    });
-});
-
-describe('Role instances', () => {
-    it('SystemRole hasPermission for granted Permission', () => {
-        const owner = getRoleByName(SystemRoles.owner);
-        expect(owner.hasPermission(Permission.content_read)).toBe(true);
-        expect(owner.hasPermission(Permission.manage_billing)).toBe(true);
-    });
-
-    it('SystemRole hasPermission false for arbitrary string', () => {
-        const reader = getRoleByName(SystemRoles.reader);
-        expect(reader.hasPermission('not_a_real_perm')).toBe(false);
-    });
-
-    it('AbacRole carries applicableScopes', () => {
-        const reader = getRoleByName(ContentRoleNames.content_reader) as AbacRole;
-        expect(reader.applicableScopes).toEqual(['document', 'collection']);
-    });
-
-    it('AbacRole permissions are bare verbs, not Permission enum values', () => {
-        const manager = getRoleByName(ContentRoleNames.content_manager);
-        expect(Array.from(manager.permissions).sort()).toEqual(['delete', 'read', 'write']);
-    });
-});
-
-describe('SystemRole vs AbacRole discrimination', () => {
-    it('SystemRole instanceof Role', () => {
-        const owner = getRoleByName(SystemRoles.owner);
-        expect(owner).toBeInstanceOf(Role);
-        expect(owner).toBeInstanceOf(SystemRole);
-        expect(owner).not.toBeInstanceOf(AbacRole);
-    });
-
-    it('AbacRole instanceof Role', () => {
-        const reader = getRoleByName(ContentRoleNames.content_reader);
-        expect(reader).toBeInstanceOf(Role);
-        expect(reader).toBeInstanceOf(AbacRole);
-        expect(reader).not.toBeInstanceOf(SystemRole);
-    });
-});
-
-describe('RoleList', () => {
-    it('fromRoleNames composes a list checkable for permissions', () => {
-        const list = RoleList.fromRoleNames([SystemRoles.reader, SystemRoles.executor]);
-        expect(list.hasPermission(Permission.content_read)).toBe(true); // from reader
-        expect(list.hasPermission(Permission.int_execute)).toBe(true); // from executor
-        expect(list.hasPermission(Permission.manage_billing)).toBe(false); // neither has it
-    });
-
-    it('fromRoleName composes a single-role list', () => {
-        const list = RoleList.fromRoleName(SystemRoles.billing);
-        expect(list.hasPermission(Permission.manage_billing)).toBe(true);
-        expect(list.hasPermission(Permission.content_write)).toBe(false);
-    });
-
-    it('throws on unknown role name', () => {
-        expect(() => RoleList.fromRoleNames(['not_real'])).toThrow(/Role not_real not found/);
-    });
-});