@gadmin2n/schematics 0.0.139 → 0.0.140

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/node-config-validator.service.spec.ts

@@ -0,0 +1,79 @@
+import { BadRequestException } from '@nestjs/common';
+import { NodeConfigValidatorService } from './node-config-validator.service';
+
+describe('NodeConfigValidatorService', () => {
+  const schema = {
+    type: 'object',
+    required: ['count', 'name'],
+    properties: {
+      count: { type: 'integer', minimum: 1 },
+      name: { type: 'string', minLength: 1 },
+    },
+    additionalProperties: false,
+  };
+
+  let service: NodeConfigValidatorService;
+
+  beforeEach(() => {
+    service = new NodeConfigValidatorService();
+  });
+
+  it('accepts an object that matches the JSON schema', () => {
+    expect(() =>
+      service.validateOrThrow('12:3', schema, { count: 2, name: 'Review' }),
+    ).not.toThrow();
+  });
+
+  it('returns stable paths, keywords and all AJV errors', () => {
+    try {
+      service.validateOrThrow('12:3', schema, { count: 0, name: '' });
+      fail('expected validation to fail');
+    } catch (error) {
+      expect(error).toBeInstanceOf(BadRequestException);
+      expect((error as BadRequestException).getResponse()).toEqual({
+        code: 'NODE_CONFIG_INVALID',
+        errors: expect.arrayContaining([
+          { path: '/count', keyword: 'minimum', message: 'must be >= 1' },
+          {
+            path: '/name',
+            keyword: 'minLength',
+            message: 'must NOT have fewer than 1 characters',
+          },
+        ]),
+      });
+      expect(
+        ((error as BadRequestException).getResponse() as { errors: unknown[] })
+          .errors,
+      ).toHaveLength(2);
+    }
+  });
+
+  it.each([null, [], 'value', 1, true])(
+    'rejects a non-object config: %p',
+    (config) => {
+      expect(() => service.validateOrThrow('12:3', schema, config)).toThrow(
+        expect.objectContaining({
+          response: {
+            code: 'NODE_CONFIG_INVALID',
+            errors: [
+              {
+                path: '/',
+                keyword: 'type',
+                message: 'must be object',
+              },
+            ],
+          },
+        }),
+      );
+    },
+  );
+
+  it('compiles a schema only once for the same caller-provided key', () => {
+    const compile = jest.spyOn((service as any).ajv, 'compile');
+
+    service.validateOrThrow('12:3', schema, { count: 1, name: 'A' });
+    service.validateOrThrow('12:3', schema, { count: 2, name: 'B' });
+
+    expect(compile).toHaveBeenCalledTimes(1);
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/node-config-validator.service.ts

@@ -0,0 +1,62 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import Ajv, { ErrorObject, ValidateFunction } from 'ajv';
+import addFormats from 'ajv-formats';
+import { JsonSchema } from './schema.types';
+
+export interface NodeConfigValidationError {
+  path: string;
+  keyword: string;
+  message: string;
+}
+
+@Injectable()
+export class NodeConfigValidatorService {
+  private readonly ajv: Ajv;
+  private readonly cache = new Map<string, ValidateFunction>();
+
+  constructor() {
+    this.ajv = new Ajv({ allErrors: true, strict: false });
+    addFormats(this.ajv);
+  }
+
+  validateOrThrow(
+    schemaKey: string,
+    schema: JsonSchema,
+    config: unknown,
+  ): void {
+    if (
+      config === null ||
+      typeof config !== 'object' ||
+      Array.isArray(config)
+    ) {
+      this.throwInvalid([
+        { path: '/', keyword: 'type', message: 'must be object' },
+      ]);
+    }
+
+    const validate =
+      this.cache.get(schemaKey) ?? this.compile(schemaKey, schema);
+
+    if (!validate(config)) {
+      this.throwInvalid((validate.errors ?? []).map(this.formatError));
+    }
+  }
+
+  private compile(schemaKey: string, schema: JsonSchema): ValidateFunction {
+    const validate = this.ajv.compile(schema);
+    this.cache.set(schemaKey, validate);
+    return validate;
+  }
+
+  private readonly formatError = (
+    error: ErrorObject,
+  ): NodeConfigValidationError => ({
+    path: error.instancePath || '/',
+    keyword: error.keyword,
+    message: error.message ?? 'is invalid',
+  });
+
+  private throwInvalid(errors: NodeConfigValidationError[]): never {
+    throw new BadRequestException({ code: 'NODE_CONFIG_INVALID', errors });
+  }
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/schema.types.ts

@@ -0,0 +1,10 @@
+export type JsonPrimitive = string | number | boolean | null;
+
+export type JsonValue =
+  | JsonPrimitive
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export type JsonSchema = Record<string, JsonValue>;
+
+export type UiSchema = Record<string, JsonValue>;

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/subject-config-validator.service.spec.ts

@@ -0,0 +1,124 @@
+import { BadRequestException } from '@nestjs/common';
+import { SubjectProviderError } from '../subjectProvider/subject-provider.errors';
+import { SubjectProviderRegistry } from '../subjectProvider/subject-provider.registry';
+import {
+  ActorContext,
+  SubjectProvider,
+} from '../subjectProvider/subject-provider.types';
+import { SubjectConfigValidatorService } from './subject-config-validator.service';
+
+const actor: ActorContext = {
+  userId: 'user-1',
+  username: 'alice',
+  roles: ['EDITOR'],
+};
+
+const schema = {
+  type: 'object',
+  properties: {
+    approval: {
+      type: 'object',
+      properties: {
+        subjects: {
+          type: 'array',
+          'x-gadmin-capability': 'subject-references',
+        },
+      },
+    },
+  },
+};
+
+function provider(): jest.Mocked<SubjectProvider> {
+  return {
+    key: 'USER_GROUP',
+    descriptor: jest.fn(),
+    search: jest.fn(),
+    create: jest.fn(),
+    validate: jest.fn().mockResolvedValue({ valid: true }),
+    preview: jest.fn(),
+    resolve: jest.fn(),
+  };
+}
+
+describe('SubjectConfigValidatorService', () => {
+  let registry: SubjectProviderRegistry;
+  let subjectProvider: jest.Mocked<SubjectProvider>;
+  let service: SubjectConfigValidatorService;
+
+  beforeEach(() => {
+    registry = new SubjectProviderRegistry();
+    subjectProvider = provider();
+    registry.register(subjectProvider);
+    service = new SubjectConfigValidatorService(registry);
+  });
+
+  it('finds annotated nested fields and validates grouped provider refs', async () => {
+    await service.validateSubjects(
+      schema,
+      {
+        approval: {
+          subjects: [
+            { provider: 'USER_GROUP', refs: ['group:ops'] },
+            { provider: 'USER_GROUP', refs: ['group:security'] },
+          ],
+        },
+      },
+      actor,
+    );
+
+    expect(subjectProvider.validate).toHaveBeenCalledWith(
+      ['group:ops', 'group:security'],
+      actor,
+    );
+  });
+
+  it('rejects malformed, duplicate, and provider-invalid references', async () => {
+    subjectProvider.validate.mockResolvedValue({
+      valid: false,
+      issues: [{ ref: 'group:missing', code: 'NOT_FOUND', message: 'Missing' }],
+    });
+
+    await expect(
+      service.validateSubjects(
+        schema,
+        {
+          approval: {
+            subjects: [{ provider: 'USER_GROUP', refs: ['group:missing'] }],
+          },
+        },
+        actor,
+      ),
+    ).rejects.toMatchObject({
+      response: { code: 'SUBJECT_REF_INVALID' },
+    });
+  });
+
+  it('preserves registry errors and sanitizes unexpected provider failures', async () => {
+    await expect(
+      service.validateSubjects(
+        schema,
+        {
+          approval: {
+            subjects: [{ provider: 'MISSING', refs: ['value'] }],
+          },
+        },
+        actor,
+      ),
+    ).rejects.toBeInstanceOf(SubjectProviderError);
+
+    subjectProvider.validate.mockRejectedValueOnce(
+      new BadRequestException({ code: 'PROVIDER_LEAK', secret: 'secret DSN' }),
+    );
+    await expect(
+      service.validateSubjects(
+        schema,
+        {
+          approval: {
+            subjects: [{ provider: 'USER_GROUP', refs: ['group:ops'] }],
+          },
+        },
+        actor,
+      ),
+    ).rejects.toMatchObject({ code: 'SUBJECT_PROVIDER_UNAVAILABLE' });
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/subject-config-validator.service.ts

@@ -0,0 +1,236 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import {
+  SubjectProviderError,
+  SubjectProviderUnavailableError,
+} from '../subjectProvider/subject-provider.errors';
+import { SubjectProviderRegistry } from '../subjectProvider/subject-provider.registry';
+import {
+  ActorContext,
+  ProviderValidationResult,
+} from '../subjectProvider/subject-provider.types';
+import { JsonSchema } from './schema.types';
+
+interface SubjectValidationIssue {
+  path: string;
+  code: string;
+  message: string;
+  provider?: string;
+  ref?: string;
+}
+
+@Injectable()
+export class SubjectConfigValidatorService {
+  constructor(private readonly registry: SubjectProviderRegistry) {}
+
+  async validateSubjects(
+    schema: JsonSchema,
+    config: unknown,
+    actor: ActorContext,
+  ): Promise<void> {
+    const annotatedValues = this.findAnnotatedValues(schema, config);
+    const grouped = new Map<string, string[]>();
+    const providerPaths = new Map<string, string>();
+    const seen = new Set<string>();
+    const seenDynamicInputs = new Set<string>();
+    const issues: SubjectValidationIssue[] = [];
+
+    for (const { path, value } of annotatedValues) {
+      if (value === undefined || value === null) continue;
+      this.parseAndGroup(
+        path,
+        value,
+        grouped,
+        providerPaths,
+        seen,
+        seenDynamicInputs,
+        issues,
+      );
+    }
+    if (issues.length > 0) this.throwInvalid(issues);
+
+    for (const [providerKey, refs] of grouped) {
+      const provider = this.registry.get(providerKey);
+      let result: ProviderValidationResult;
+      try {
+        result = await provider.validate(refs, actor);
+      } catch (error) {
+        if (error instanceof SubjectProviderError) throw error;
+        throw new SubjectProviderUnavailableError(providerKey);
+      }
+
+      if (!result.valid) {
+        this.throwInvalid(
+          (result.issues ?? []).map((issue) => ({
+            path: providerPaths.get(providerKey) ?? '/',
+            provider: providerKey,
+            ...(issue.ref !== undefined && { ref: issue.ref }),
+            code: issue.code,
+            message: issue.message,
+          })),
+        );
+      }
+    }
+  }
+
+  private findAnnotatedValues(
+    schema: unknown,
+    config: unknown,
+    propertyPath: readonly string[] = [],
+  ): { path: string; value: unknown }[] {
+    if (!isRecord(schema)) return [];
+
+    const current = this.valueAt(config, propertyPath);
+    const results =
+      schema['x-gadmin-capability'] === 'subject-references'
+        ? [{ path: toJsonPointer(propertyPath), value: current }]
+        : [];
+
+    const properties = schema.properties;
+    if (!isRecord(properties)) return results;
+
+    for (const [property, childSchema] of Object.entries(properties)) {
+      results.push(
+        ...this.findAnnotatedValues(childSchema, config, [
+          ...propertyPath,
+          property,
+        ]),
+      );
+    }
+    return results;
+  }
+
+  private valueAt(value: unknown, path: readonly string[]): unknown {
+    let current = value;
+    for (const segment of path) {
+      if (!isRecord(current)) return undefined;
+      current = current[segment];
+    }
+    return current;
+  }
+
+  private parseAndGroup(
+    path: string,
+    value: unknown,
+    grouped: Map<string, string[]>,
+    providerPaths: Map<string, string>,
+    seen: Set<string>,
+    seenDynamicInputs: Set<string>,
+    issues: SubjectValidationIssue[],
+  ): void {
+    if (!Array.isArray(value)) {
+      issues.push({
+        path,
+        code: 'INVALID_SUBJECTS',
+        message: 'subject references must be an array',
+      });
+      return;
+    }
+
+    value.forEach((entry, index) => {
+      const entryPath = `${path}/${index}`;
+      if (!isRecord(entry)) {
+        issues.push({
+          path: entryPath,
+          code: 'INVALID_SUBJECT',
+          message: 'subject reference must be an object',
+        });
+        return;
+      }
+
+      const provider = validNonBlankString(entry.provider);
+      const source = entry.source ?? 'STATIC';
+      const rawRefs = entry.refs;
+      if (!provider) {
+        issues.push({
+          path: `${entryPath}/provider`,
+          code: 'INVALID_PROVIDER',
+          message: 'provider must be a nonblank string',
+        });
+      }
+      if (source === 'DYNAMIC') {
+        const inputKey = validNonBlankString(entry.inputKey);
+        if (!inputKey) {
+          issues.push({
+            path: `${entryPath}/inputKey`,
+            code: 'INVALID_DYNAMIC_INPUT',
+            message: 'inputKey must be a nonblank string',
+          });
+        } else if (seenDynamicInputs.has(inputKey)) {
+          issues.push({
+            path: `${entryPath}/inputKey`,
+            code: 'DUPLICATE_DYNAMIC_INPUT',
+            message: 'dynamic input keys must be unique',
+          });
+        } else {
+          seenDynamicInputs.add(inputKey);
+        }
+        if (provider) {
+          grouped.set(provider, grouped.get(provider) ?? []);
+          if (!providerPaths.has(provider))
+            providerPaths.set(provider, entryPath);
+        }
+        return;
+      }
+      if (!Array.isArray(rawRefs) || rawRefs.length === 0) {
+        issues.push({
+          path: `${entryPath}/refs`,
+          code: 'INVALID_REFS',
+          message: 'refs must be a non-empty array',
+        });
+        return;
+      }
+
+      rawRefs.forEach((rawRef, refIndex) => {
+        const ref = validNonBlankString(rawRef);
+        if (!ref) {
+          issues.push({
+            path: `${entryPath}/refs/${refIndex}`,
+            code: 'INVALID_REF',
+            message: 'ref must be a nonblank string',
+          });
+          return;
+        }
+        if (!provider) return;
+
+        const duplicateKey = `${provider}\0${ref}`;
+        if (seen.has(duplicateKey)) {
+          issues.push({
+            path: `${entryPath}/refs/${refIndex}`,
+            provider,
+            ref,
+            code: 'DUPLICATE_REF',
+            message: 'duplicate ref for provider',
+          });
+          return;
+        }
+
+        seen.add(duplicateKey);
+        grouped.set(provider, [...(grouped.get(provider) ?? []), ref]);
+        if (!providerPaths.has(provider)) providerPaths.set(provider, path);
+      });
+    });
+  }
+
+  private throwInvalid(issues: SubjectValidationIssue[]): never {
+    throw new BadRequestException({ code: 'SUBJECT_REF_INVALID', issues });
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function validNonBlankString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0
+    ? value.trim() === value
+      ? value
+      : undefined
+    : undefined;
+}
+
+function toJsonPointer(path: readonly string[]): string {
+  if (path.length === 0) return '/';
+  return `/${path
+    .map((segment) => segment.replace(/~/g, '~0').replace(/\//g, '~1'))
+    .join('/')}`;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/widget-catalog.service.spec.ts

@@ -0,0 +1,49 @@
+import { WidgetCatalogService } from './widget-catalog.service';
+
+describe('WidgetCatalogService', () => {
+  it('accepts the built-in workflow widgets used by seeded node types', () => {
+    const catalog = new WidgetCatalogService();
+
+    expect(() =>
+      catalog.assertUiSchemaSupported({
+        webhook: { widget: 'external-request-config' },
+        approvalResult: { widget: 'submit-approval-result-config' },
+        externalResult: { widget: 'submit-external-result-config' },
+        externalWait: { widget: 'external-wait-config' },
+        callableInputs: { widget: 'callable-input-parameters' },
+        approvalRequest: { widget: 'approval-request-trigger-config' },
+        returnResult: { widget: 'return-result-config' },
+      }),
+    ).not.toThrow();
+  });
+
+  it('accepts primitive widgets and newly registered generic widgets', () => {
+    const catalog = new WidgetCatalogService();
+    catalog.register('custom-picker');
+
+    expect(() =>
+      catalog.assertUiSchemaSupported({
+        name: { widget: 'text' },
+        nested: [{ field: { widget: 'custom-picker' } }],
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects an unregistered widget with its nested path', () => {
+    const catalog = new WidgetCatalogService();
+
+    expect(() =>
+      catalog.assertUiSchemaSupported({
+        approval: { subjects: { widget: 'missing-widget' } },
+      }),
+    ).toThrow(
+      expect.objectContaining({
+        response: {
+          code: 'NODE_WIDGET_NOT_REGISTERED',
+          widget: 'missing-widget',
+          path: '/approval/subjects/widget',
+        },
+      }),
+    );
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/widget-catalog.service.ts

@@ -0,0 +1,69 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+
+const PRIMITIVE_WIDGETS = [
+  'text',
+  'textarea',
+  'number',
+  'boolean',
+  'select',
+  'object',
+  'array',
+] as const;
+
+const WORKFLOW_WIDGETS = [
+  'callable-input-parameters',
+  'approval-request-trigger-config',
+  'return-result-config',
+  'external-request-config',
+  'submit-approval-result-config',
+  'submit-external-result-config',
+  'external-wait-config',
+] as const;
+
+@Injectable()
+export class WidgetCatalogService {
+  private readonly widgets = new Set<string>([
+    ...PRIMITIVE_WIDGETS,
+    ...WORKFLOW_WIDGETS,
+  ]);
+
+  register(widget: string): void {
+    if (typeof widget !== 'string' || widget.trim().length === 0) {
+      throw new BadRequestException('widget name must be a nonblank string');
+    }
+    this.widgets.add(widget);
+  }
+
+  assertUiSchemaSupported(uiSchema: unknown): void {
+    this.walk(uiSchema, []);
+  }
+
+  private walk(value: unknown, path: readonly (string | number)[]): void {
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => this.walk(item, [...path, index]));
+      return;
+    }
+    if (value === null || typeof value !== 'object') return;
+
+    for (const [key, child] of Object.entries(value)) {
+      const childPath = [...path, key];
+      if (key === 'widget' && typeof child === 'string') {
+        if (!this.widgets.has(child)) {
+          throw new BadRequestException({
+            code: 'NODE_WIDGET_NOT_REGISTERED',
+            widget: child,
+            path: toJsonPointer(childPath),
+          });
+        }
+      } else {
+        this.walk(child, childPath);
+      }
+    }
+  }
+}
+
+function toJsonPointer(path: readonly (string | number)[]): string {
+  return `/${path
+    .map((segment) => String(segment).replace(/~/g, '~0').replace(/\//g, '~1'))
+    .join('/')}`;
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/workflowConfig.module.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { SubjectProviderModule } from '../subjectProvider/subjectProvider.module';
+import { NodeConfigValidatorService } from './node-config-validator.service';
+import { SubjectConfigValidatorService } from './subject-config-validator.service';
+import { WidgetCatalogService } from './widget-catalog.service';
+
+@Module({
+  imports: [SubjectProviderModule],
+  providers: [
+    NodeConfigValidatorService,
+    SubjectConfigValidatorService,
+    WidgetCatalogService,
+  ],
+  exports: [
+    NodeConfigValidatorService,
+    SubjectConfigValidatorService,
+    WidgetCatalogService,
+  ],
+})
+export class WorkflowConfigModule {}

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/node-instance-config.util.spec.ts

@@ -0,0 +1,15 @@
+import { hashNodeInstanceConfig } from './node-instance-config.util';
+
+describe('node-instance-config.util', () => {
+  it('hashes objects independently of key insertion order', () => {
+    expect(hashNodeInstanceConfig({ a: 1, b: { x: true, y: null } })).toBe(
+      hashNodeInstanceConfig({ b: { y: null, x: true }, a: 1 }),
+    );
+  });
+
+  it('preserves array order', () => {
+    expect(hashNodeInstanceConfig({ refs: ['a', 'b'] })).not.toBe(
+      hashNodeInstanceConfig({ refs: ['b', 'a'] }),
+    );
+  });
+});

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowNodeInstance/node-instance-config.util.ts

@@ -0,0 +1,25 @@
+import { Prisma } from '@prisma/client';
+import { createHash } from 'node:crypto';
+
+function sortJson(value: Prisma.JsonValue): Prisma.JsonValue {
+  if (Array.isArray(value)) return value.map(sortJson);
+
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([key, nestedValue]) => [
+          key,
+          nestedValue === undefined ? nestedValue : sortJson(nestedValue),
+        ]),
+    );
+  }
+
+  return value;
+}
+
+export const canonicalizeConfig = (config: Prisma.JsonValue): string =>
+  JSON.stringify(sortJson(config));
+
+export const hashNodeInstanceConfig = (config: Prisma.JsonValue): string =>
+  createHash('sha256').update(canonicalizeConfig(config)).digest('hex');