@squiz/dx-json-schema-lib 1.85.1 → 1.85.2

package/src/manifest/userApi/v1/userApiManifest.integration.spec.ts

@@ -0,0 +1,265 @@
+import fs from 'fs';
+import path from 'path';
+import type { JSONSchema } from '@squiz/json-schema-library';
+import Draft07Schema from '../../v1/Draft-07.json';
+import { JSONSchemaService, SchemaValidationError, TypeResolverBuilder } from '../../..';
+
+/** Must align with `integration-fixtures/valid-full.manifest.json` `$schema`. */
+const FULL_MANIFEST_FIXTURE_SCHEMA =
+  'https://unpkg.com/@squiz/dx-json-schema-lib@latest/lib/manifest/userApiManifest/UserApiManifestV1.json';
+
+/** Directory containing `UserApiManifestV1.json` (this spec sits alongside those files). */
+const USER_API_SCHEMA_DIR = __dirname;
+
+/** `src/manifest/userApi/v1` → package root (four levels up). */
+const PACKAGE_ROOT = path.join(USER_API_SCHEMA_DIR, '..', '..', '..', '..');
+
+const draft07Remotes = {
+  'http://json-schema.org/draft-07/schema': Draft07Schema,
+  'http://json-schema.org/draft-07/schema#': Draft07Schema,
+} as const;
+
+function loadJson(relPathUnderSrcDir: string): unknown {
+  const abs = path.isAbsolute(relPathUnderSrcDir)
+    ? relPathUnderSrcDir
+    : path.join(USER_API_SCHEMA_DIR, relPathUnderSrcDir);
+  return JSON.parse(fs.readFileSync(abs, 'utf8')) as unknown;
+}
+
+function fixture(name: string): unknown {
+  return loadJson(path.join('integration-fixtures', name));
+}
+
+function fixtureRecord(name: string): Record<string, unknown> {
+  return fixture(name) as Record<string, unknown>;
+}
+
+/** Standalone resolved manifests: validated only after {@link wrapResolvedFixtureAsFull}. */
+const INVALID_WRAPPED_FIXTURES = [
+  'invalid-nested-manifest-name.manifest.json',
+  'invalid-nested-manifest-handlerMap.manifest.json',
+  'invalid-endpoint-extra-public.manifest.json',
+  'invalid-endpoint-handler-leading-digit.manifest.json',
+  'invalid-endpoint-handler-hyphen.manifest.json',
+  'invalid-endpoint-method-invalid.manifest.json',
+  'invalid-endpoint-missing-method.manifest.json',
+  'invalid-endpoint-missing-path.manifest.json',
+  'invalid-resolved-empty-endpoints.manifest.json',
+  'invalid-resolved-no-leading-slash.manifest.json',
+] as const;
+
+/** Full top-level documents consumed directly by {@link JSONSchemaService.validateInput}. */
+const INVALID_FULL_MANIFEST_FIXTURES = [
+  'invalid-full-root-extra-property.manifest.json',
+  'invalid-full-name-empty.manifest.json',
+  'invalid-full-displayName-empty.manifest.json',
+  'invalid-full-missing-schema.manifest.json',
+  'invalid-full-missing-manifest.manifest.json',
+  'invalid-full-manifest-not-object.manifest.json',
+] as const;
+
+type FixtureEndpoint = {
+  path: string;
+  method: string;
+  handler: string;
+};
+
+/** Non-schema regression check: validators must not omit or reorder fixture endpoint fields. */
+function expectFixtureEndpointsUnchanged(validated: unknown) {
+  const data = validated as { manifest?: { endpoints: FixtureEndpoint[] }; endpoints?: FixtureEndpoint[] };
+  const endpoints = data.manifest?.endpoints ?? data.endpoints;
+  expect(endpoints).toHaveLength(2);
+
+  expect(endpoints!).toContainEqual({
+    path: '/integration/hello',
+    method: 'GET',
+    handler: 'index.helloWorld',
+  });
+  expect(endpoints!).toContainEqual({
+    path: '/integration/items',
+    method: 'POST',
+    handler: 'handlers.createItem',
+  });
+}
+
+/** Wrap standalone resolved fixture JSON under a minimal UserApiManifestV1 root (only full manifest is validated publicly). */
+function wrapResolvedFixtureAsFull(resolved: Record<string, unknown>) {
+  return {
+    $schema: FULL_MANIFEST_FIXTURE_SCHEMA,
+    name: typeof resolved.name === 'string' ? resolved.name : 'wrapped-api',
+    displayName: 'Integration fixture envelope',
+    description: '',
+    filesDir: 'src',
+    entry: 'index.ts',
+    manifest: resolved,
+  };
+}
+
+function createFullManifestValidator(schemaFromDisk: JSONSchema) {
+  const resolver = TypeResolverBuilder.new().build();
+  return new JSONSchemaService(resolver, {
+    root: schemaFromDisk,
+    remotes: draft07Remotes,
+  });
+}
+
+describe('user-api JSON schemas (integration, filesystem-backed)', () => {
+  describe('published schema documents on disk', () => {
+    it('parses UserApiManifestV1.json and exposes nested resolved manifest definition', () => {
+      const schema = loadJson('UserApiManifestV1.json') as Record<string, unknown>;
+      expect(schema.$schema).toBe('http://json-schema.org/draft-07/schema#');
+      expect(schema.title).toBe('UserApiManifestV1');
+      expect(schema.additionalProperties).toBe(false);
+
+      expect(schema.required).toEqual(
+        expect.arrayContaining(['$schema', 'name', 'displayName', 'filesDir', 'entry', 'manifest']),
+      );
+
+      const { resolvedApiManifest } = schema.definitions as {
+        resolvedApiManifest: {
+          properties: Record<string, unknown>;
+          required: string[];
+        };
+      };
+      expect(resolvedApiManifest.required).toEqual(expect.arrayContaining(['endpoints']));
+
+      const rootProps = schema.properties as { manifest: { $ref?: string } };
+      expect(rootProps.manifest.$ref).toBe('#/definitions/resolvedApiManifest');
+
+      expect(resolvedApiManifest.properties).toHaveProperty('endpoints');
+      expect(Object.keys(resolvedApiManifest.properties ?? {})).toEqual(['endpoints']);
+      expect(resolvedApiManifest.required).toEqual(['endpoints']);
+    });
+
+    it('UserApiManifestV1 endpoint items require path, method, handler only and forbid extra endpoint keys', () => {
+      const schema = loadJson('UserApiManifestV1.json') as {
+        definitions: {
+          resolvedApiManifest: {
+            properties: {
+              endpoints: {
+                items: {
+                  required: string[];
+                  additionalProperties?: boolean;
+                  properties?: Record<string, unknown>;
+                };
+              };
+            };
+          };
+        };
+      };
+      const items = schema.definitions.resolvedApiManifest.properties.endpoints.items;
+      expect(items.required).toEqual(['path', 'method', 'handler']);
+      expect(items.additionalProperties).toBe(false);
+      expect(items.properties).toMatchObject({
+        path: expect.objectContaining({ type: 'string' }),
+        method: expect.objectContaining({ type: 'string' }),
+        handler: expect.objectContaining({ type: 'string' }),
+      });
+      expect(Object.keys(items.properties ?? {})).toHaveLength(3);
+    });
+
+    it('UserApiManifestV1 nested resolved manifest forbids arbitrary root keys (endpoints only)', () => {
+      const schema = loadJson('UserApiManifestV1.json') as {
+        definitions: { resolvedApiManifest: { additionalProperties?: boolean } };
+      };
+      expect(schema.definitions.resolvedApiManifest.additionalProperties).toBe(false);
+    });
+  });
+
+  describe('validation pipeline using schemas read from filesystem (not TS imports)', () => {
+    const fullManifestSchemaRoot = loadJson('UserApiManifestV1.json') as JSONSchema;
+    const fullValidator = createFullManifestValidator(fullManifestSchemaRoot);
+    const validResolved = fixtureRecord('valid-resolved.manifest.json');
+
+    function expectRejectWhenWrapped(filename: string) {
+      expect(() => fullValidator.validateInput(wrapResolvedFixtureAsFull(fixtureRecord(filename)))).toThrow(
+        SchemaValidationError,
+      );
+    }
+
+    function expectRejectFullDocument(blob: unknown) {
+      expect(() => fullValidator.validateInput(blob)).toThrow(SchemaValidationError);
+    }
+
+    it.each(INVALID_WRAPPED_FIXTURES)('rejects wrapped nested manifest from %s', (filename) => {
+      expectRejectWhenWrapped(filename);
+    });
+
+    it.each(INVALID_FULL_MANIFEST_FIXTURES)('rejects full manifest document %s', (filename) => {
+      expectRejectFullDocument(fixture(filename));
+    });
+
+    it('accepts realistic full manifest fixture aligned with nested endpoint schema', () => {
+      const blob = fixture('valid-full.manifest.json');
+      expect(fullValidator.validateInput(blob)).toBe(true);
+      expectFixtureEndpointsUnchanged(blob);
+    });
+
+    it('accepts valid-resolved fixture when wrapped under a minimal full manifest envelope', () => {
+      const wrapped = wrapResolvedFixtureAsFull(validResolved);
+      expect(fullValidator.validateInput(wrapped)).toBe(true);
+      expectFixtureEndpointsUnchanged(wrapped);
+    });
+
+    it('valid-resolved fixture is endpoints-only at nested root (no manifest.name)', () => {
+      expect(Array.isArray(validResolved.endpoints)).toBe(true);
+    });
+
+    it('accepts api-builder-style paths (wildcard and :param) using disk-backed schema', () => {
+      const wrapped = wrapResolvedFixtureAsFull({
+        endpoints: [
+          { path: '/hello/*', method: 'GET', handler: 'hello' },
+          { path: '/user/:id/:type', method: 'GET', handler: 'user' },
+        ],
+      });
+      expect(fullValidator.validateInput(wrapped)).toBe(true);
+    });
+
+    it('accepts alternate $schema URL on envelope (filesystem validation path)', () => {
+      const blob = {
+        $schema: 'https://raw.githubusercontent.com/user/api-builder-prototype/main/schemas/api-builder.schema.json',
+        name: 'integration-proto',
+        displayName: 'Proto',
+        filesDir: 'src',
+        entry: 'index.ts',
+        manifest: {
+          endpoints: [{ path: '/health', method: 'GET', handler: 'health' }],
+        },
+      };
+      expect(fullValidator.validateInput(blob)).toBe(true);
+    });
+
+    it('accepts full manifest when optional description is omitted', () => {
+      expect(fullValidator.validateInput(fixture('valid-full-no-description.manifest.json'))).toBe(true);
+    });
+
+    it('accepts one endpoint per allowed HTTP method value', () => {
+      const blob = fixture('valid-full-each-http-method.manifest.json') as {
+        manifest: { endpoints: { method: string }[] };
+      };
+      expect(fullValidator.validateInput(blob)).toBe(true);
+      expect(blob.manifest.endpoints.map((e) => e.method).sort()).toEqual(
+        ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT'].sort(),
+      );
+    });
+
+    it('accepts minimal path "/" in wrapped resolved fixture alongside another endpoint', () => {
+      const wrapped = wrapResolvedFixtureAsFull(fixtureRecord('valid-resolved-slash-path.manifest.json'));
+      expect(fullValidator.validateInput(wrapped)).toBe(true);
+      const endpoints = (wrapped.manifest as { endpoints: { path: string }[] }).endpoints;
+      expect(endpoints.some((e) => e.path === '/')).toBe(true);
+    });
+  });
+
+  describe('artifacts under lib/ after compile (when present)', () => {
+    const srcFull = path.join(USER_API_SCHEMA_DIR, 'UserApiManifestV1.json');
+    const libFull = path.join(PACKAGE_ROOT, 'lib', 'manifest', 'userApi', 'v1', 'UserApiManifestV1.json');
+
+    const libExists = fs.existsSync(libFull);
+    const itOrSkip = libExists ? it : it.skip;
+
+    itOrSkip('copied lib UserApiManifestV1.json payload matches src', () => {
+      expect(loadJson(libFull)).toEqual(loadJson(srcFull));
+    });
+  });
+});

package/src/manifest/userApi/v1/userApiManifestValidation.spec.ts

@@ -0,0 +1,311 @@
+import {
+  USER_API_FULL_MANIFEST_SCHEMA,
+  USER_API_MANIFEST_SCHEMA_URL,
+  validateUserApiFullManifest,
+} from './userApiManifestValidation';
+import { SchemaValidationError } from '../../../errors/SchemaValidationError';
+
+describe('user API manifest validation', () => {
+  const validResolved = {
+    endpoints: [{ path: '/hello', method: 'GET', handler: 'index.hello' }],
+  };
+
+  const validFull = {
+    $schema: USER_API_MANIFEST_SCHEMA_URL,
+    name: 'api',
+    displayName: 'API',
+    description: '',
+    filesDir: 'src',
+    entry: 'index.ts',
+    manifest: validResolved,
+  };
+
+  /** Resolves `#/definitions/resolvedApiManifest` via the full-manifest root schema only. */
+  const wrapResolved = (manifestNested: Record<string, unknown>) => ({
+    ...validFull,
+    manifest: manifestNested,
+  });
+
+  const endpoint = (
+    overrides: Partial<{
+      path: string;
+      method: string;
+      handler: string;
+    }> = {},
+  ) => ({
+    path: '/r',
+    method: 'GET',
+    handler: 'handler',
+    ...overrides,
+  });
+
+  const expectResolvedNestedThrows = (manifestNested: Record<string, unknown>) => {
+    expect(() => validateUserApiFullManifest(wrapResolved(manifestNested))).toThrow(SchemaValidationError);
+  };
+
+  const expectFullThrows = (input: unknown) => {
+    expect(() => validateUserApiFullManifest(input)).toThrow(SchemaValidationError);
+  };
+
+  it('surfaces bundled full manifest schema for CDN / tooling', () => {
+    expect(USER_API_FULL_MANIFEST_SCHEMA.type).toBe('object');
+    expect(typeof USER_API_MANIFEST_SCHEMA_URL).toBe('string');
+    expect(USER_API_MANIFEST_SCHEMA_URL).toContain('dx-json-schema-lib');
+    expect(USER_API_MANIFEST_SCHEMA_URL).toContain('manifest/userApiManifest');
+  });
+
+  describe('nested resolvedApiManifest rules (validated only through validateUserApiFullManifest)', () => {
+    it('accepts canonical resolved manifest when nested under manifest', () => {
+      expect(validateUserApiFullManifest(wrapResolved(validResolved))).toBe(true);
+    });
+
+    it.each(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'] as const)(
+      'accepts HTTP method %s',
+      (method) => {
+        expect(
+          validateUserApiFullManifest(
+            wrapResolved({
+              endpoints: [endpoint({ path: `/m-${method}`, method })],
+            }),
+          ),
+        ).toBe(true);
+      },
+    );
+
+    it('accepts multiple endpoints without extra endpoint fields', () => {
+      expect(
+        validateUserApiFullManifest(
+          wrapResolved({
+            endpoints: [
+              { path: '/a', method: 'GET', handler: 'a' },
+              { path: '/b', method: 'POST', handler: 'mod.b' },
+            ],
+          }),
+        ),
+      ).toBe(true);
+    });
+
+    it('rejects handlerMap on nested manifest (endpoints only)', () => {
+      expectResolvedNestedThrows({
+        endpoints: [endpoint()],
+        handlerMap: { 'index.hello': './handlers/hello.ts' },
+      });
+    });
+
+    it('accepts handlers using $ and nested module paths', () => {
+      expect(
+        validateUserApiFullManifest(
+          wrapResolved({
+            endpoints: [
+              endpoint({ handler: '$default' }),
+              endpoint({ handler: 'ns.deep_export' }),
+              endpoint({ handler: '_private' }),
+            ],
+          }),
+        ),
+      ).toBe(true);
+    });
+
+    it('accepts path with only slash', () => {
+      expect(validateUserApiFullManifest(wrapResolved({ endpoints: [endpoint({ path: '/' })] }))).toBe(true);
+    });
+
+    it('accepts api-builder prototype document (alternate $schema, endpoints-only nested manifest)', () => {
+      expect(
+        validateUserApiFullManifest({
+          $schema: 'https://raw.githubusercontent.com/user/api-builder-prototype/main/schemas/api-builder.schema.json',
+          name: 'test-api',
+          displayName: 'Test Api',
+          description: 'An API to test the proxy endpoint',
+          entry: 'index.ts',
+          filesDir: 'src',
+          manifest: {
+            endpoints: [
+              { path: '/hello/*', method: 'GET', handler: 'hello' },
+              { path: '/add', method: 'GET', handler: 'add' },
+              { path: '/user/:id/:type', method: 'GET', handler: 'user' },
+              { path: '/proxy', method: 'GET', handler: 'proxy' },
+              { path: '/health', method: 'GET', handler: 'health' },
+            ],
+          },
+        }),
+      ).toBe(true);
+    });
+
+    it('rejects empty endpoints array', () => {
+      expectResolvedNestedThrows({ endpoints: [] });
+      expectFullThrows({
+        ...validFull,
+        manifest: { endpoints: [] },
+      });
+    });
+
+    it('accepts nested manifest with only endpoints (no nested name)', () => {
+      expect(
+        validateUserApiFullManifest(
+          wrapResolved({
+            endpoints: [endpoint()],
+          }),
+        ),
+      ).toBe(true);
+    });
+
+    it('rejects nested manifest name property (nested root allows only endpoints)', () => {
+      expectResolvedNestedThrows({ name: 'nested-id', endpoints: [endpoint()] });
+      expectResolvedNestedThrows({ name: '', endpoints: [endpoint()] });
+    });
+
+    it('rejects missing endpoints on nested manifest', () => {
+      expectResolvedNestedThrows({ name: 'only-name' });
+    });
+
+    it('rejects non-array endpoints on nested manifest', () => {
+      expectResolvedNestedThrows({ endpoints: {} });
+    });
+
+    it('rejects nested manifest root additionalProperties', () => {
+      expectResolvedNestedThrows({ ...validResolved, extraKey: true });
+    });
+
+    it('rejects extra properties on an endpoint object', () => {
+      expectResolvedNestedThrows({
+        endpoints: [{ ...endpoint(), unknownFlag: true }],
+      });
+    });
+
+    it.each(['path', 'method', 'handler'] as const)('rejects endpoint missing required field %s', (field) => {
+      const ep = endpoint();
+      const partial = Object.fromEntries(Object.entries(ep).filter(([k]) => k !== field)) as Record<string, unknown>;
+      expectResolvedNestedThrows({
+        endpoints: [partial],
+      });
+    });
+
+    it('accepts minimal endpoint objects (only path/method/handler)', () => {
+      expect(
+        validateUserApiFullManifest(
+          wrapResolved({
+            endpoints: [{ path: '/x', method: 'GET', handler: 'h' }],
+          }),
+        ),
+      ).toBe(true);
+    });
+
+    it('rejects paths without a leading slash', () => {
+      expectResolvedNestedThrows({
+        endpoints: [endpoint({ path: 'no-leading-slash' })],
+      });
+    });
+
+    it('rejects invalid HTTP methods', () => {
+      expectResolvedNestedThrows({
+        endpoints: [endpoint({ method: 'TRACE' })],
+      });
+      expectResolvedNestedThrows({
+        endpoints: [endpoint({ method: 'get' })],
+      });
+    });
+
+    it.each([
+      { handler: '', reason: 'empty handler' },
+      { handler: '9start', reason: 'leading digit' },
+      { handler: 'bad-handler', reason: 'hyphen' },
+      { handler: 'a b', reason: 'space' },
+      { handler: '😀', reason: 'non-ASCII' },
+    ])('rejects invalid handler ($reason)', ({ handler }) => {
+      expectResolvedNestedThrows({
+        endpoints: [endpoint({ handler })],
+      });
+    });
+
+    it('rejects invalid nested manifest object shapes', () => {
+      expectFullThrows(wrapResolved({} as Record<string, unknown>));
+      expectFullThrows({
+        ...validFull,
+        manifest: [] as unknown,
+      });
+      expectFullThrows({
+        ...validFull,
+        manifest: 'nested' as unknown,
+      });
+    });
+  });
+
+  describe('validateUserApiFullManifest (root document)', () => {
+    it('accepts canonical full manifest', () => {
+      expect(validateUserApiFullManifest(validFull)).toBe(true);
+    });
+
+    it('accepts omission of optional description', () => {
+      const { description: _d, ...noDesc } = validFull;
+      expect(validateUserApiFullManifest(noDesc)).toBe(true);
+    });
+
+    it('accepts endpoints-only nested manifest when root declares name', () => {
+      expect(
+        validateUserApiFullManifest({
+          ...validFull,
+          name: 'root-name',
+          manifest: {
+            endpoints: [{ path: '/e', method: 'GET', handler: 'eh' }],
+          },
+        }),
+      ).toBe(true);
+    });
+
+    it('rejects missing root $schema', () => {
+      const { $schema: _drop, ...withoutSchema } = validFull;
+      expectFullThrows(withoutSchema);
+    });
+
+    it('rejects empty $schema string', () => {
+      expectFullThrows({ ...validFull, $schema: '' });
+    });
+
+    it.each([['name'], ['displayName'], ['filesDir'], ['entry'], ['manifest']] as const)(
+      'rejects full manifest missing required field %s',
+      (field) => {
+        const { [field]: _removed, ...rest } = validFull as Record<string, unknown>;
+        expectFullThrows(rest);
+      },
+    );
+
+    it.each([
+      ['name', ''],
+      ['displayName', ''],
+      ['filesDir', ''],
+      ['entry', ''],
+    ] as const)('rejects empty string for %s (minLength 1)', (field, value) => {
+      expectFullThrows({
+        ...validFull,
+        [field]: value,
+      });
+    });
+
+    it('rejects root additionalProperties on full manifest', () => {
+      expectFullThrows({ ...validFull, version: '1' });
+    });
+
+    it('rejects nested manifest validation failures (delegates to resolved definition)', () => {
+      expectFullThrows({
+        ...validFull,
+        manifest: {
+          endpoints: [endpoint(), endpoint({ handler: '$default', path: '/other' })],
+          badRootKey: true,
+        },
+      });
+      expectFullThrows({
+        ...validFull,
+        manifest: { endpoints: [] },
+      });
+    });
+
+    it('rejects primitives instead of manifest object root', () => {
+      expectFullThrows(null);
+      expectFullThrows(undefined);
+      expectFullThrows([]);
+      expectFullThrows('manifest');
+      expectFullThrows({});
+    });
+  });
+});

package/src/manifest/userApi/v1/userApiManifestValidation.ts

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import Draft07Schema from '../../v1/Draft-07.json';
+import UserApiManifestV1 from './UserApiManifestV1.json';
+import { JSONSchemaService } from '../../../JsonSchemaService';
+import { TypeResolverBuilder } from '../../../jsonTypeResolution/TypeResolverBuilder';
+
+const pkgVersion = ((): string | undefined => {
+  try {
+    const pkgPath = path.join(__dirname, '..', '..', '..', '..', 'package.json');
+    const raw = fs.readFileSync(pkgPath, 'utf8');
+    return (JSON.parse(raw) as { version?: string }).version;
+  } catch {
+    return undefined;
+  }
+})();
+
+const draft07Remotes = {
+  'http://json-schema.org/draft-07/schema': Draft07Schema,
+  'http://json-schema.org/draft-07/schema#': Draft07Schema,
+} as const;
+
+const fullManifestMetaSchema = {
+  root: UserApiManifestV1,
+  remotes: draft07Remotes,
+} as const;
+
+const resolver = TypeResolverBuilder.new().build();
+
+const fullManifestValidator = new JSONSchemaService(resolver, fullManifestMetaSchema);
+
+/**
+ * Recommended `$schema` URL for the top-level DXP User API `manifest.json`.
+ *
+ * Published at {@link USER_API_FULL_MANIFEST_SCHEMA} under `lib/manifest/userApiManifest/UserApiManifestV1.json`.
+ */
+export const USER_API_MANIFEST_SCHEMA_URL =
+  typeof pkgVersion === 'string'
+    ? `https://unpkg.com/@squiz/dx-json-schema-lib@${pkgVersion}/lib/manifest/userApiManifest/UserApiManifestV1.json`
+    : 'https://unpkg.com/@squiz/dx-json-schema-lib@latest/lib/manifest/userApiManifest/UserApiManifestV1.json';
+
+/**
+ * JSON Schema bundle validating the full on-disk manifest (CLI / zip upload).
+ */
+export { default as USER_API_FULL_MANIFEST_SCHEMA } from './UserApiManifestV1.json';
+
+/**
+ * Validate the User API manifest before upload.
+ *
+ * @throws {SchemaValidationError} when validation fails.
+ */
+export function validateUserApiFullManifest(input: unknown): true {
+  return fullManifestValidator.validateInput(input);
+}