=> {
+ if (!obj) return obj;
+ const removedDiffs = obj?.[od]?.removed ?? {};
+
+ const removedItems = Object.entries(removedDiffs).map(([k, c]) => [
+ k,
+ (c as any).before,
+ ]);
+
+ return {
+ ...obj,
+ ...Object.fromEntries(removedItems),
+ };
+};
+
+export const objectPropWithChangelog = (
+ parent: WithOpticDiffs
,
+ key: K
+): [P[K], Changelog[K]> | undefined] => {
+ if (Array.isArray(parent))
+ throw new Error(
+ 'This method cannot be used safely on arrays because a removed and an added items can share the same key'
+ );
+ const diffs = parent?.[od];
+ const changelog =
+ diffs?.added?.[key] ?? diffs?.changed?.[key] ?? diffs?.removed?.[key];
+ const removed = changelog?.type === 'removed';
+ const value = removed ? changelog.before : parent[key];
+ return [value, changelog];
+};
+
+export const allUnreserved = (
+ obj: T,
+ reservedKeys: string[]
+) => omit(objectWithRemovedItems(obj), [...reservedKeys, or]) ?? {};
+
+export const mapChangelog = (
+ changelog: Changelog | undefined,
+ mapper: (t: T) => V
+): Changelog | undefined =>
+ !changelog
+ ? undefined
+ : changelog?.type === 'added'
+ ? changelog
+ : {
+ type: changelog.type,
+ before: mapper(changelog.before),
+ };
+
+export const hasChanges = (obj: ChangelogTree | undefined) =>
+ obj?.[od]?.hasNestedChanges === true;
diff --git a/projects/optic/web/src/app/utils/changelog-tree.ts b/projects/optic/web/src/app/utils/changelog-tree.ts
new file mode 100644
index 0000000000..b9fc353640
--- /dev/null
+++ b/projects/optic/web/src/app/utils/changelog-tree.ts
@@ -0,0 +1,211 @@
+import { jsonPointerHelpers } from '@useoptic/json-pointer-helpers';
+import cloneDeep from 'lodash.clonedeep';
+import type { ObjectDiff, RuleResult } from '@useoptic/openapi-utilities';
+import { reconcileDiff } from '@useoptic/openapi-utilities';
+
+export const od = Symbol.for('optic_diffs');
+export const or = Symbol.for('optic_results');
+
+export type Changelog =
+ | {
+ type: 'added';
+ }
+ | {
+ type: 'changed';
+ before: T;
+ }
+ | {
+ type: 'removed';
+ before: T;
+ };
+
+export type OpticDiffs = {
+ added?: Partial<{
+ [K in keyof T]: Changelog & { type: 'added' };
+ }>;
+ changed?: Partial<{
+ [K in keyof T]: Changelog & { type: 'changed' };
+ }>;
+ removed?: Partial<{
+ [K in keyof T]: Changelog & { type: 'removed' };
+ }>;
+ hasNestedChanges?: boolean;
+};
+
+export type WithOpticDiffs = T & {
+ [od]?: OpticDiffs;
+};
+
+export type WithOpticResults = T & {
+ [or]?: RuleResult[];
+};
+
+export type ChangelogTree = ([T] extends [object | undefined]
+ ? [
+ {
+ [K in keyof T]: ChangelogTree;
+ } & WithOpticDiffs &
+ WithOpticResults,
+ ]
+ : [T])[0];
+
+const getIn = (tree: object, pathSegments: string[]): any => {
+ let obj: any = tree;
+ for (const [ix, pathSegment] of pathSegments.entries()) {
+ if (!(pathSegment in obj)) {
+ if (ix === pathSegments.length - 1) {
+ return undefined;
+ } else {
+ throw new Error(
+ `getIn: invalid "${pathSegment}" path at index ${ix} of ${pathSegments.join(
+ '/'
+ )}. ${
+ obj === 'null'
+ ? `obj is null`
+ : typeof obj === 'object'
+ ? `Object keys are ${Object.keys(obj)}`
+ : `obj is ${typeof obj}`
+ }`
+ );
+ }
+ }
+ obj = obj[pathSegment];
+ }
+ return obj;
+};
+
+const setInDiff = (
+ tree: T,
+ pathSegments: string[],
+ changelog: Changelog
+): T => {
+ const changelogType = changelog.type;
+ const parentLocation = pathSegments.slice(0, -1);
+ const childKey = pathSegments.at(-1);
+ if (!childKey) throw new Error('empty path');
+
+ let obj: any = tree;
+ obj[od] = {
+ ...(obj[od] ?? {}),
+ hasNestedChanges: true,
+ };
+ for (const path of parentLocation) {
+ if (!obj || !(path in obj)) {
+ throw new Error(
+ `setIn: invalid "${path}" path in ${parentLocation.join('/')}`
+ );
+ }
+
+ obj = obj[path];
+
+ obj[od] = {
+ ...(obj[od] ?? {}),
+ hasNestedChanges: true,
+ };
+ }
+
+ if (!obj || typeof obj !== 'object') throw new Error('Expected an object');
+
+ obj[od] = {
+ ...(obj[od] ?? {}),
+ [changelogType]: {
+ ...(obj[od]?.[changelogType] ?? {}),
+ [childKey]: changelog,
+ },
+ };
+ return tree;
+};
+
+export const setInResult = (
+ tree: T,
+ pathSegments: string[],
+ result: RuleResult
+) => {
+ let obj: any = tree;
+
+ obj[od] = {
+ ...(obj[od] ?? {}),
+ hasNestedChanges: true,
+ };
+
+ for (const [ix, pathSegment] of pathSegments.entries()) {
+ const nextObj =
+ result.location.spec === 'before'
+ ? obj?.[od]?.removed?.[pathSegment]?.before ?? obj[pathSegment]
+ : obj[pathSegment];
+ if (
+ !nextObj ||
+ typeof nextObj !== 'object' ||
+ ix === pathSegments.length - 1
+ ) {
+ const target =
+ !!nextObj &&
+ typeof nextObj === 'object' &&
+ ix === pathSegments.length - 1
+ ? nextObj
+ : obj;
+ target[or] = [...(target[or] ?? []), result];
+ target[od] = {
+ ...(target[od] ?? {}),
+ hasNestedChanges: true,
+ };
+ return;
+ }
+ obj = nextObj;
+ obj[od] = {
+ ...(obj[od] ?? {}),
+ hasNestedChanges: true,
+ };
+ }
+
+ return;
+};
+
+const removeLeadingSlash = (s: string) =>
+ s.charAt(0) === '/' ? s.slice(1) : s;
+
+export const getDiffSegments = (diff: string) =>
+ removeLeadingSlash(diff).split('/').map(jsonPointerHelpers.unescape);
+
+export const buildChangelogTree = (
+ before: object,
+ after: T,
+ diffs: ObjectDiff[]
+): ChangelogTree => {
+ const changelogTree = cloneDeep(after);
+
+ for (const diff of diffs) {
+ // Removed
+ if (diff.before !== undefined && diff.after === undefined) {
+ const afterPath = getDiffSegments(reconcileDiff(diff).before!);
+ const beforePath = getDiffSegments(diff.before);
+
+ setInDiff(changelogTree, afterPath, {
+ type: 'removed',
+ before: getIn(before, beforePath),
+ });
+ }
+
+ // Added
+ else if (diff.before === undefined && diff.after !== undefined) {
+ const afterPath = getDiffSegments(diff.after);
+
+ setInDiff(changelogTree, afterPath, {
+ type: 'added',
+ });
+ }
+
+ // Changed
+ else if (diff.before !== undefined && diff.after !== undefined) {
+ const afterPath = getDiffSegments(diff.after);
+ const beforePath = getDiffSegments(diff.before);
+
+ setInDiff(changelogTree, afterPath, {
+ type: 'changed',
+ before: getIn(before, beforePath),
+ });
+ }
+ }
+
+ return changelogTree;
+};
diff --git a/projects/optic/web/src/app/utils/index.ts b/projects/optic/web/src/app/utils/index.ts
new file mode 100644
index 0000000000..0a514c4f71
--- /dev/null
+++ b/projects/optic/web/src/app/utils/index.ts
@@ -0,0 +1,71 @@
+// TODO - this should be made into a common utilities to be used across FE + BE
+
+import * as Swagger2 from './swagger2';
+import * as OAS3 from './oas3';
+import * as OAS3_1 from './oas3_1';
+import type { InternalSpec, InternalSpecEndpoint } from './types';
+import { ojp } from './utils';
+
+type SupportedVersions = '2.x.x' | '3.0.x' | '3.1.x';
+
+export * from './all-items';
+export * from './changelog-tree';
+export * from './utils';
+export * from './operationId';
+export { attachRuleResults, addOpticResultsToOriginal } from './rules';
+
+export function createEmptySpec(): InternalSpec {
+ return {
+ metadata: {
+ version: '',
+ servers: {},
+ info: {},
+ misc: {},
+ [ojp]: '',
+ },
+ endpoints: {},
+ };
+}
+
+export function specToInternal(
+ spec: any,
+ version: SupportedVersions
+): InternalSpec {
+ if (version === '3.0.x') {
+ return OAS3.specToInternal(spec);
+ } else if (version === '3.1.x') {
+ return OAS3_1.specToInternal(spec);
+ } else if (version === '2.x.x') {
+ return Swagger2.specToInternal(spec);
+ }
+ throw new Error(`unimplemented version ${version}`);
+}
+
+export function endpointToInternal(
+ endpoint: any,
+ { path, method }: { path: string; method: string },
+ version: SupportedVersions
+): InternalSpecEndpoint {
+ if (version === '3.0.x') {
+ return OAS3.endpointToInternal(endpoint, { path, method });
+ } else if (version === '3.1.x') {
+ return OAS3_1.endpointToInternal(endpoint, { path, method });
+ } else if (version === '2.x.x') {
+ return Swagger2.endpointToInternal(endpoint, { path, method });
+ }
+
+ throw new Error(`unimplemented version ${version}`);
+}
+
+export function specToInternalInferVersion(spec: any): InternalSpec {
+ const version = spec.swagger
+ ? '2.x.x'
+ : spec.openapi?.startsWith('3.0.')
+ ? '3.0.x'
+ : '3.1.x';
+
+ return specToInternal(spec, version);
+}
+
+export { Swagger2, OAS3, OAS3_1 };
+export * from './types';
diff --git a/projects/optic/web/src/app/utils/oas3.ts b/projects/optic/web/src/app/utils/oas3.ts
new file mode 100644
index 0000000000..5b916c7997
--- /dev/null
+++ b/projects/optic/web/src/app/utils/oas3.ts
@@ -0,0 +1,377 @@
+import { OpenAPIV3 } from '@useoptic/openapi-utilities';
+import { jsonPointerHelpers } from '@useoptic/json-pointer-helpers';
+import { getParameterKey, ojp } from './utils';
+
+import {
+ normalizeOpenApiPath,
+ type FlatOpenAPIV3,
+} from '@useoptic/openapi-utilities';
+import {
+ UnnamedPolymorphic,
+ type InternalSpec,
+ type InternalSpecContent,
+ type InternalSpecEndpoint,
+ type InternalSpecParameter,
+ type InternalSpecRequestBody,
+ type InternalSpecResponse,
+ type InternalSpecSchema,
+ type InternalSpecSchemaField,
+} from './types';
+import { getOperationId } from './operationId';
+
+function getRestFromSchema(schema: any) {
+ const {
+ anyOf,
+ oneOf,
+ allOf,
+ not,
+ type,
+ properties,
+ items,
+ example,
+ additionalProperties,
+ title,
+ description,
+ nullable,
+ required,
+ ...rest
+ } = schema;
+ return rest;
+}
+
+function schemaToInternal(
+ schema: FlatOpenAPIV3.SchemaObject,
+ schemaPath: string
+): InternalSpecSchema {
+ // If schema.type isn't set, but there's properties we can infer it's a object type
+ if (!schema.type && schema.properties) schema.type = 'object';
+
+ const rest = getRestFromSchema(schema);
+ const examples: any[] = [];
+ if (schema.example) examples.push(schema.example);
+ const polymorphic = schema.anyOf || schema.oneOf;
+ const common = {
+ title: schema.title,
+ description: schema.description,
+ examples,
+ misc: rest,
+ };
+
+ const nullableVariant = schema.nullable
+ ? schemaToInternal(
+ {
+ type: 'null' as any,
+ },
+ schemaPath
+ )
+ : null;
+ // Assumption is we've flattened allOf variants
+ if (polymorphic) {
+ const polymorphicKey = schema.anyOf ? 'anyOf' : 'oneOf';
+ const schemas = [
+ ...polymorphic.map((s, i) =>
+ schemaToInternal(
+ s,
+ jsonPointerHelpers.append(schemaPath, polymorphicKey, String(i))
+ )
+ ),
+ ];
+ if (nullableVariant) {
+ schemas.push(nullableVariant);
+ }
+ return {
+ ...common,
+ polymorphicKey,
+ schemas,
+ [ojp]: schemaPath,
+ };
+ } else {
+ let baseSchema: InternalSpecSchema;
+ if (schema.type === 'array') {
+ baseSchema = {
+ ...common,
+ polymorphicKey: null,
+ type: 'array',
+ value: 'array',
+ items: schemaToInternal(
+ schema.items ?? {},
+ jsonPointerHelpers.append(schemaPath, 'items')
+ ),
+ [ojp]: schemaPath,
+ };
+ } else if (schema.type === 'object') {
+ const properties: Record = {};
+ for (const [key, value] of Object.entries(schema.properties ?? {})) {
+ const internalSchema = schemaToInternal(
+ value ?? {},
+ jsonPointerHelpers.append(schemaPath, 'properties', key)
+ );
+ properties[key] = {
+ key,
+ required: schema.required?.includes(key) ?? false,
+ ...internalSchema,
+ };
+ }
+ baseSchema = {
+ ...common,
+ polymorphicKey: null,
+ type: 'object',
+ value: 'object',
+ properties,
+ [ojp]: schemaPath,
+ additionalProperties:
+ schema.additionalProperties === undefined ||
+ typeof schema.additionalProperties === 'boolean'
+ ? schema.additionalProperties
+ : schemaToInternal(
+ schema.additionalProperties,
+ jsonPointerHelpers.append(schemaPath, 'additionalProperties')
+ ),
+ };
+ } else {
+ baseSchema = {
+ ...common,
+ polymorphicKey: null,
+ type: 'primitive',
+ value: schema.type ?? 'any',
+ [ojp]: schemaPath,
+ };
+ }
+ if (nullableVariant) {
+ return {
+ examples: [],
+ misc: {},
+ polymorphicKey: UnnamedPolymorphic,
+ schemas: [baseSchema, nullableVariant],
+ [ojp]: schemaPath,
+ };
+ } else {
+ return baseSchema;
+ }
+ }
+}
+
+// Accepts FlatOpenAPIV3.ParameterObject or FlatOpenAPIV3.MediaTypeObject
+function mediaObjectToInternal(
+ mediaObject: {
+ schema?: FlatOpenAPIV3.SchemaObject;
+ example?: any;
+ examples?: { [media: string]: any };
+ },
+ originalPath: string
+) {
+ const maybeInternalSchema = mediaObject.schema
+ ? schemaToInternal(
+ mediaObject.schema,
+ jsonPointerHelpers.append(originalPath, 'schema')
+ )
+ : mediaObject.schema;
+ // For bodies, examples can live both on the schema level and the body level in OAS3
+ if (maybeInternalSchema) {
+ if (mediaObject.example)
+ maybeInternalSchema.examples.push(mediaObject.example);
+ if (mediaObject.examples) {
+ for (const example of Object.values(mediaObject.examples))
+ maybeInternalSchema.examples.push(example);
+ }
+ }
+ return maybeInternalSchema;
+}
+
+export function endpointToInternal(
+ oas3Endpoint: FlatOpenAPIV3.OperationObject,
+ { path, method }: { path: string; method: string }
+): InternalSpecEndpoint {
+ const { summary, description, parameters, responses, requestBody, ...rest } =
+ oas3Endpoint;
+ const internalParameters: Record = {};
+ const internalResponses: Record = {};
+ let internalRequestBody: InternalSpecRequestBody | undefined = undefined;
+ const baseEndpointPath = jsonPointerHelpers.compile(['paths', path, method]);
+
+ for (let i = 0; i < (parameters?.length ?? 0); i++) {
+ const parameter = (parameters ?? [])[i];
+ const {
+ name,
+ in: paramIn,
+ required,
+ description,
+ example,
+ examples,
+ schema,
+ content,
+ ...rest
+ } = parameter;
+ const parameterPath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'parameters',
+ String(i)
+ );
+
+ const key = getParameterKey(name, paramIn);
+ internalParameters[key] = {
+ name,
+ in: paramIn,
+ description,
+ required: required ?? false,
+ schema: mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ parameterPath
+ ),
+ misc: rest,
+ [ojp]: parameterPath,
+ };
+ }
+
+ if (requestBody) {
+ const { required, content, description, ...rest } = requestBody;
+ const internalContent: InternalSpecContent = {};
+ const requestBodyPath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'requestBody'
+ );
+
+ for (const [contentType, body] of Object.entries(content ?? {})) {
+ const { schema, example, examples, encoding } = body;
+ const internalSchema = mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ jsonPointerHelpers.append(requestBodyPath, 'content', contentType)
+ );
+ if (internalSchema) {
+ if (encoding) internalSchema.misc.encoding = encoding;
+ internalContent[contentType] = internalSchema;
+ }
+ }
+
+ internalRequestBody = {
+ required: required ?? false,
+ description,
+ content: internalContent,
+ misc: rest,
+ [ojp]: requestBodyPath,
+ };
+ }
+
+ for (const [statusCode, response] of Object.entries(responses ?? {})) {
+ const { content, headers, description, ...rest } = response;
+ const internalContent: InternalSpecContent = {};
+ const internalHeaders: Record = {};
+ const baseResponsePath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'responses',
+ statusCode
+ );
+
+ for (const [name, header] of Object.entries(headers ?? {})) {
+ const { required, schema, example, examples, description, ...rest } =
+ header;
+ const headerPath = jsonPointerHelpers.append(
+ baseResponsePath,
+ 'headers',
+ name
+ );
+ internalHeaders[name] = {
+ name,
+ in: 'header',
+ description,
+ required: required ?? false,
+ schema: mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ headerPath
+ ),
+ [ojp]: headerPath,
+ misc: rest,
+ };
+ }
+
+ for (const [contentType, body] of Object.entries(content ?? {})) {
+ const { schema, example, examples, encoding } = body;
+ const internalSchema = mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ jsonPointerHelpers.append(baseResponsePath, 'content', contentType)
+ );
+ if (internalSchema) {
+ if (encoding) internalSchema.misc.encoding = encoding;
+ internalContent[contentType] = internalSchema;
+ }
+ }
+
+ internalResponses[statusCode] = {
+ description,
+ content: internalContent,
+ headers: internalHeaders,
+ misc: rest,
+ [ojp]: baseResponsePath,
+ };
+ }
+
+ return {
+ path,
+ method,
+ summary,
+ description,
+ parameters: internalParameters,
+ requestBody: internalRequestBody,
+ responses: internalResponses,
+ misc: rest,
+ [ojp]: baseEndpointPath,
+ };
+}
+
+export function specToInternal(oas3Spec: FlatOpenAPIV3.Document): InternalSpec {
+ const {
+ servers,
+ paths,
+ components,
+ openapi,
+ info,
+ tags,
+ externalDocs,
+ security,
+ 'x-optic-ci-empty-spec': _,
+ ...rest
+ } = oas3Spec as FlatOpenAPIV3.Document & { 'x-optic-ci-empty-spec'?: string };
+ const internalServers: Record = {};
+ for (const server of servers ?? []) {
+ internalServers[server.url] = server;
+ }
+
+ const metadata: InternalSpec['metadata'] = {
+ version: openapi,
+ servers: internalServers,
+ info,
+ tags,
+ externalDocs,
+ security,
+ misc: rest,
+ [ojp]: jsonPointerHelpers.compile(['/']),
+ };
+ const endpoints: InternalSpec['endpoints'] = {};
+ for (const [path, pathObj] of Object.entries(paths ?? {})) {
+ for (const method of Object.values(OpenAPIV3.HttpMethods)) {
+ const endpoint = pathObj?.[method];
+ const normalized = normalizeOpenApiPath(path);
+ if (endpoint) {
+ endpoints[getOperationId({ method, pathPattern: normalized })] =
+ endpointToInternal(endpoint, { path, method });
+ }
+ }
+ }
+ return { endpoints, metadata };
+}
diff --git a/projects/optic/web/src/app/utils/oas3_1.ts b/projects/optic/web/src/app/utils/oas3_1.ts
new file mode 100644
index 0000000000..cefdbbb68a
--- /dev/null
+++ b/projects/optic/web/src/app/utils/oas3_1.ts
@@ -0,0 +1,431 @@
+import { OpenAPIV3 } from '@useoptic/openapi-utilities';
+import { jsonPointerHelpers } from '@useoptic/json-pointer-helpers';
+import { getParameterKey, ojp } from './utils';
+
+import {
+ normalizeOpenApiPath,
+ type FlatOpenAPIV3_1,
+} from '@useoptic/openapi-utilities';
+import {
+ UnnamedPolymorphic,
+ type InternalSpec,
+ type InternalSpecContent,
+ type InternalSpecEndpoint,
+ type InternalSpecParameter,
+ type InternalSpecRequestBody,
+ type InternalSpecResponse,
+ type InternalSpecSchema,
+ type InternalSpecSchemaField,
+} from './types';
+import { getOperationId } from './operationId';
+
+function getRestFromSchema(schema: any) {
+ const {
+ anyOf,
+ oneOf,
+ allOf,
+ not,
+ type,
+ properties,
+ items,
+ example,
+ title,
+ additionalProperties,
+ description,
+ required,
+ ...rest
+ } = schema;
+ return rest;
+}
+
+const objectReservedKeywords = new Set([
+ 'properties',
+ 'maxProperties',
+ 'minProperties',
+ 'required',
+ 'dependentRequired',
+]);
+const arrayReservedKeywords = new Set([
+ 'maxItems',
+ 'minItems',
+ 'uniqueItems',
+ 'maxContains',
+ 'minContains',
+]);
+const numberReservedKeywords = new Set([
+ 'multipleOf',
+ 'maximum',
+ 'exclusiveMaximum',
+ 'minimum',
+ 'exclusiveMinimum',
+]);
+const stringReservedKeywords = new Set(['maxLength', 'minLength', 'pattern']);
+
+function objectWithKeys(
+ obj: T,
+ fn: (k: keyof T) => boolean
+): T {
+ return Object.entries(obj).reduce((acc, [k, v]) => {
+ if (fn(k as keyof T)) acc[k] = v;
+
+ return acc;
+ }, {} as any);
+}
+
+function schemaToInternal(
+ schema: FlatOpenAPIV3_1.SchemaObject,
+ schemaPath: string
+): InternalSpecSchema {
+ // If schema.type isn't set, but there's properties we can infer it's a object type
+ if (!schema.type && schema.properties) schema.type = 'object';
+ const rest = getRestFromSchema(schema);
+ const examples: any[] = [];
+ if (schema.example) examples.push(schema.example);
+ const polymorphic = schema.anyOf || schema.oneOf;
+ const common = {
+ title: schema.title,
+ description: schema.description,
+ examples,
+ misc: rest,
+ };
+
+ // Assumption is we've flattened allOf variants
+ if (polymorphic) {
+ const polymorphicKey = schema.anyOf ? 'anyOf' : 'oneOf';
+ return {
+ ...common,
+ polymorphicKey,
+ schemas: polymorphic.map((s, i) =>
+ schemaToInternal(
+ s,
+ jsonPointerHelpers.append(schemaPath, polymorphicKey, String(i))
+ )
+ ),
+ [ojp]: schemaPath,
+ };
+ } else if (Array.isArray(schema.type)) {
+ const schemaWithNoReservedKeys = objectWithKeys(
+ schema,
+ (key) =>
+ !(
+ objectReservedKeywords.has(key) ||
+ arrayReservedKeywords.has(key) ||
+ numberReservedKeywords.has(key) ||
+ stringReservedKeywords.has(key)
+ )
+ );
+ return {
+ misc: {},
+ examples: [],
+ polymorphicKey: UnnamedPolymorphic,
+ schemas: schema.type
+ .map((type) => {
+ let extraKeys: Record = {};
+ if (type === 'object') {
+ extraKeys = objectWithKeys(schema, (k) =>
+ objectReservedKeywords.has(k)
+ );
+ } else if (type === 'array') {
+ extraKeys = objectWithKeys(schema, (k) =>
+ arrayReservedKeywords.has(k)
+ );
+ } else if (type === 'number' || type === 'integer') {
+ extraKeys = objectWithKeys(schema, (k) =>
+ numberReservedKeywords.has(k)
+ );
+ } else if (type === 'string') {
+ extraKeys = objectWithKeys(schema, (k) =>
+ stringReservedKeywords.has(k)
+ );
+ }
+ return {
+ ...schemaWithNoReservedKeys,
+ ...extraKeys,
+ type: type === null ? 'null' : type,
+ } as FlatOpenAPIV3_1.SchemaObject;
+ })
+ .map((s) => schemaToInternal(s, schemaPath)),
+ [ojp]: schemaPath,
+ };
+ } else {
+ if (schema.type === 'array') {
+ return {
+ ...common,
+ polymorphicKey: null,
+ type: 'array',
+ value: 'array',
+ items: schemaToInternal(
+ schema.items ?? {},
+ jsonPointerHelpers.append(schemaPath, 'items')
+ ),
+ [ojp]: schemaPath,
+ };
+ } else if (schema.type === 'object') {
+ const properties: Record = {};
+ for (const [key, value] of Object.entries(schema.properties ?? {})) {
+ const internalSchema = schemaToInternal(
+ value ?? {},
+ jsonPointerHelpers.append(schemaPath, 'properties', key)
+ );
+ properties[key] = {
+ key,
+ required: schema.required?.includes(key) ?? false,
+ ...internalSchema,
+ };
+ }
+ return {
+ ...common,
+ polymorphicKey: null,
+ type: 'object',
+ value: 'object',
+ properties,
+ [ojp]: schemaPath,
+ additionalProperties:
+ schema.additionalProperties === undefined ||
+ typeof schema.additionalProperties === 'boolean'
+ ? schema.additionalProperties
+ : schemaToInternal(
+ schema.additionalProperties,
+ jsonPointerHelpers.append(schemaPath, 'additionalProperties')
+ ),
+ };
+ } else {
+ return {
+ ...common,
+ polymorphicKey: null,
+ type: 'primitive',
+ value: schema.type ?? 'any',
+ [ojp]: schemaPath,
+ };
+ }
+ }
+}
+
+// Accepts FlatOpenAPIV3_1.ParameterObject or FlatOpenAPIV3_1.MediaTypeObject
+function mediaObjectToInternal(
+ mediaObject: {
+ schema?: FlatOpenAPIV3_1.SchemaObject;
+ example?: any;
+ examples?: { [media: string]: any };
+ },
+ originalPath: string
+) {
+ const maybeInternalSchema = mediaObject.schema
+ ? schemaToInternal(
+ mediaObject.schema,
+ jsonPointerHelpers.append(originalPath, 'schema')
+ )
+ : mediaObject.schema;
+ // For bodies, examples can live both on the schema level and the body level in OAS3
+ if (maybeInternalSchema) {
+ if (mediaObject.example)
+ maybeInternalSchema.examples.push(mediaObject.example);
+ if (mediaObject.examples) {
+ for (const example of Object.values(mediaObject.examples))
+ maybeInternalSchema.examples.push(example);
+ }
+ }
+ return maybeInternalSchema;
+}
+
+export function endpointToInternal(
+ oas3Endpoint: FlatOpenAPIV3_1.OperationObject,
+ { path, method }: { path: string; method: string }
+): InternalSpecEndpoint {
+ const { summary, description, parameters, responses, requestBody, ...rest } =
+ oas3Endpoint;
+ const internalParameters: Record = {};
+ const internalResponses: Record = {};
+ let internalRequestBody: InternalSpecRequestBody | undefined = undefined;
+ const baseEndpointPath = jsonPointerHelpers.compile(['paths', path, method]);
+
+ for (let i = 0; i < (parameters?.length ?? 0); i++) {
+ const parameter = (parameters ?? [])[i];
+ const {
+ name,
+ in: paramIn,
+ required,
+ description,
+ example,
+ examples,
+ schema,
+ content,
+ ...rest
+ } = parameter;
+ const parameterPath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'parameters',
+ String(i)
+ );
+
+ const key = getParameterKey(name, paramIn);
+ internalParameters[key] = {
+ name,
+ in: paramIn,
+ description,
+ required: required ?? false,
+ schema: mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ parameterPath
+ ),
+ misc: rest,
+ [ojp]: parameterPath,
+ };
+ }
+
+ if (requestBody) {
+ const { required, content, description, ...rest } = requestBody;
+ const internalContent: InternalSpecContent = {};
+ const requestBodyPath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'requestBody'
+ );
+
+ for (const [contentType, body] of Object.entries(content ?? {})) {
+ const { schema, example, examples, encoding } = body;
+ const internalSchema = mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ jsonPointerHelpers.append(requestBodyPath, 'content', contentType)
+ );
+ if (internalSchema) {
+ if (encoding) internalSchema.misc.encoding = encoding;
+ internalContent[contentType] = internalSchema;
+ }
+ }
+
+ internalRequestBody = {
+ required: required ?? false,
+ description,
+ content: internalContent,
+ misc: rest,
+ [ojp]: requestBodyPath,
+ };
+ }
+
+ for (const [statusCode, response] of Object.entries(responses ?? {})) {
+ const { content, headers, description, ...rest } = response;
+ const internalContent: InternalSpecContent = {};
+ const internalHeaders: Record = {};
+ const baseResponsePath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'responses',
+ statusCode
+ );
+
+ for (const [name, header] of Object.entries(headers ?? {})) {
+ const { required, schema, example, examples, description, ...rest } =
+ header;
+ const headerPath = jsonPointerHelpers.append(
+ baseResponsePath,
+ 'headers',
+ name
+ );
+ internalHeaders[name] = {
+ name,
+ in: 'header',
+ description,
+ required: required ?? false,
+ schema: mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ headerPath
+ ),
+ [ojp]: headerPath,
+ misc: rest,
+ };
+ }
+
+ for (const [contentType, body] of Object.entries(content ?? {})) {
+ const { schema, example, examples, encoding } = body;
+ const internalSchema = mediaObjectToInternal(
+ {
+ schema,
+ example,
+ examples,
+ },
+ jsonPointerHelpers.append(baseResponsePath, 'content', contentType)
+ );
+ if (internalSchema) {
+ if (encoding) internalSchema.misc.encoding = encoding;
+ internalContent[contentType] = internalSchema;
+ }
+ }
+
+ internalResponses[statusCode] = {
+ description,
+ content: internalContent,
+ headers: internalHeaders,
+ misc: rest,
+ [ojp]: baseResponsePath,
+ };
+ }
+
+ return {
+ path,
+ method,
+ summary,
+ description,
+ parameters: internalParameters,
+ requestBody: internalRequestBody,
+ responses: internalResponses,
+ misc: rest,
+ [ojp]: baseEndpointPath,
+ };
+}
+
+export function specToInternal(
+ oas3Spec: FlatOpenAPIV3_1.Document
+): InternalSpec {
+ const {
+ servers,
+ paths,
+ components,
+ openapi,
+ info,
+ tags,
+ externalDocs,
+ security,
+ 'x-optic-ci-empty-spec': _,
+ ...rest
+ } = oas3Spec as FlatOpenAPIV3_1.Document & {
+ 'x-optic-ci-empty-spec'?: string;
+ };
+ const internalServers: Record = {};
+ for (const server of servers ?? []) {
+ internalServers[server.url] = server;
+ }
+
+ const metadata: InternalSpec['metadata'] = {
+ version: openapi,
+ servers: internalServers,
+ info,
+ tags,
+ externalDocs,
+ security,
+ misc: rest,
+ [ojp]: jsonPointerHelpers.compile(['/']),
+ };
+ const endpoints: InternalSpec['endpoints'] = {};
+ for (const [path, pathObj] of Object.entries(paths ?? {})) {
+ for (const method of Object.values(OpenAPIV3.HttpMethods)) {
+ const endpoint = pathObj?.[method];
+ const normalized = normalizeOpenApiPath(path);
+ if (endpoint) {
+ endpoints[getOperationId({ method, pathPattern: normalized })] =
+ endpointToInternal(endpoint, { path, method });
+ }
+ }
+ }
+ return { endpoints, metadata };
+}
diff --git a/projects/optic/web/src/app/utils/operationId.ts b/projects/optic/web/src/app/utils/operationId.ts
new file mode 100644
index 0000000000..09285958c4
--- /dev/null
+++ b/projects/optic/web/src/app/utils/operationId.ts
@@ -0,0 +1,10 @@
+// This should not be changed as the ID is used in the URLs
+export const getOperationId = (operation: {
+ pathPattern: string;
+ method: string;
+}) => `${operation.method}.${operation.pathPattern}`;
+
+export const parseOperationId = (operationId: string) => {
+ const [method, ...pathSegments] = operationId.split('.');
+ return { method, path: pathSegments.join('.') };
+};
diff --git a/projects/optic/web/src/app/utils/rules.ts b/projects/optic/web/src/app/utils/rules.ts
new file mode 100644
index 0000000000..4257991abd
--- /dev/null
+++ b/projects/optic/web/src/app/utils/rules.ts
@@ -0,0 +1,104 @@
+import type { RuleResult } from '@useoptic/openapi-utilities';
+import type { InternalSpec } from './types';
+import { getDiffSegments, setInResult } from './changelog-tree';
+import { ojp } from './utils';
+import { jsonPointerHelpers } from '@useoptic/json-pointer-helpers';
+import { objectWithRemovedItems } from './all-items';
+
+type PathTree = Record;
+
+function buildPaths(
+ obj: any,
+ path: string,
+ map: PathTree,
+ withRemoved: boolean
+) {
+ if (!obj) {
+ return;
+ }
+
+ if (Array.isArray(obj)) {
+ obj.forEach((v, i) => {
+ buildPaths(
+ v,
+ jsonPointerHelpers.append(path, String(i)),
+ map,
+ withRemoved
+ );
+ });
+ } else if (typeof obj === 'object') {
+ if (obj[ojp]) {
+ const parts = jsonPointerHelpers.decode(obj[ojp]);
+ let cur = map;
+ for (const part of parts.slice(0, -1)) {
+ if (!cur[part]) {
+ cur[part] = {
+ specPath: null,
+ children: {},
+ };
+ }
+ cur = cur[part].children;
+ }
+ const last = parts[parts.length - 1];
+ if (cur[last]) {
+ cur[last].specPath = path;
+ } else {
+ cur[last] = {
+ specPath: path,
+ children: {},
+ };
+ }
+ }
+ const allObj = withRemoved ? objectWithRemovedItems(obj) : obj;
+
+ for (const [key, value] of Object.entries(allObj)) {
+ buildPaths(value, jsonPointerHelpers.append(path, key), map, withRemoved);
+ }
+ }
+}
+
+export function attachRuleResults(
+ spec: InternalSpec,
+ results: RuleResult[]
+): InternalSpec {
+ const pathMap: PathTree = {};
+ buildPaths(spec, '', pathMap, false);
+ const withRemovedPathMap: PathTree = {};
+ buildPaths(spec, '', withRemovedPathMap, true);
+
+ for (const result of results) {
+ if (result.passed || result.exempted) continue;
+
+ let specPath = jsonPointerHelpers.compile(['metadata']);
+ let current: PathTree =
+ result.location.spec === 'after' ? pathMap : withRemovedPathMap;
+ for (const part of jsonPointerHelpers.decode(result.location.jsonPath)) {
+ const child = current[part];
+ if (child) {
+ if (child.specPath !== null) {
+ specPath = child.specPath;
+ }
+ current = child.children;
+ } else {
+ break;
+ }
+ }
+ // TODO fix this to apply to multiple paths in internal spec (e.g. we might render a single json path to multiple locations)
+ setInResult(spec, jsonPointerHelpers.decode(specPath), result);
+ }
+
+ return spec;
+}
+
+export const addOpticResultsToOriginal = (
+ after: T,
+ results: RuleResult[]
+) => {
+ for (const result of results) {
+ if (result.passed || result.exempted) continue;
+ const pathSegments = getDiffSegments(result.location.jsonPath);
+ setInResult(after, pathSegments, result);
+ }
+
+ return after;
+};
diff --git a/projects/optic/web/src/app/utils/swagger2.ts b/projects/optic/web/src/app/utils/swagger2.ts
new file mode 100644
index 0000000000..772445da98
--- /dev/null
+++ b/projects/optic/web/src/app/utils/swagger2.ts
@@ -0,0 +1,394 @@
+import {
+ normalizeOpenApiPath,
+ type FlatOpenAPIV2,
+} from '@useoptic/openapi-utilities';
+import type { IJsonSchema } from '@useoptic/openapi-utilities/build/flat-openapi-types';
+import { jsonPointerHelpers } from '@useoptic/json-pointer-helpers';
+import type {
+ InternalSpec,
+ InternalSpecContent,
+ InternalSpecEndpoint,
+ InternalSpecMetadata,
+ InternalSpecParameter,
+ InternalSpecRequestBody,
+ InternalSpecResponse,
+ InternalSpecSchema,
+ InternalSpecSchemaField,
+} from './types';
+import { getParameterKey, ojp } from './utils';
+import { getOperationId } from './operationId';
+
+const SWAGGER2_HTTP_METHODS = [
+ 'get',
+ 'put',
+ 'post',
+ 'delete',
+ 'options',
+ 'head',
+ 'patch',
+] as const;
+
+const FORM_CONTENT_TYPES = new Set([
+ 'application/x-www-form-urlencoded',
+ 'multipart/form-data',
+]);
+
+function getRestFromSchema(schema: any) {
+ const {
+ anyOf,
+ oneOf,
+ allOf,
+ not,
+ type,
+ properties,
+ items,
+ example,
+ additionalProperties,
+ title,
+ description,
+ discriminator,
+ required,
+ ...rest
+ } = schema;
+ return rest;
+}
+function schemaToInternal(
+ schema: T,
+ schemaPath: string
+): InternalSpecSchema {
+ // If schema.type isn't set, but there's properties we can infer it's a object type
+ if (!schema.type && schema.properties) schema.type = 'object';
+ const rest = getRestFromSchema(schema);
+ const examples: any[] = [];
+ if ('example' in schema) examples.push(schema.example);
+ const common = {
+ title: 'title' in schema ? schema.title : undefined,
+ description: 'description' in schema ? schema.description : undefined,
+ examples,
+ misc: rest,
+ };
+
+ if ('allOf' in schema && schema.allOf) {
+ const polymorphicKey =
+ 'discriminator' in schema
+ ? `allOf (discriminator ${schema.discriminator})`
+ : 'allOf';
+
+ return {
+ ...common,
+ polymorphicKey,
+ schemas: schema.allOf.map((s, i) =>
+ schemaToInternal(
+ s,
+ jsonPointerHelpers.append(schemaPath, polymorphicKey, String(i))
+ )
+ ),
+ [ojp]: schemaPath,
+ };
+ } else {
+ if (schema.type === 'array') {
+ const items = Array.isArray(schema.items)
+ ? schema.items[0]
+ : schema.items ?? {};
+ return {
+ ...common,
+ polymorphicKey: null,
+ type: 'array',
+ value: 'array',
+ items: schemaToInternal(
+ items,
+ jsonPointerHelpers.append(schemaPath, 'items')
+ ),
+ [ojp]: schemaPath,
+ };
+ } else if (schema.type === 'object') {
+ const properties: Record = {};
+ for (const [key, value] of Object.entries(schema.properties ?? {})) {
+ const internalSchema = schemaToInternal(
+ value,
+ jsonPointerHelpers.append(schemaPath, 'properties', key)
+ );
+ properties[key] = {
+ key,
+ required: schema.required?.includes(key) ?? false,
+ ...internalSchema,
+ };
+ }
+ return {
+ ...common,
+ polymorphicKey: null,
+ type: 'object',
+ value: 'object',
+ properties,
+ [ojp]: schemaPath,
+ additionalProperties:
+ schema.additionalProperties === undefined ||
+ typeof schema.additionalProperties === 'boolean'
+ ? schema.additionalProperties
+ : schemaToInternal(
+ schema.additionalProperties,
+ jsonPointerHelpers.append(schemaPath, 'additionalProperties')
+ ),
+ };
+ } else {
+ return {
+ ...common,
+ polymorphicKey: null,
+ type: 'primitive',
+ value: Array.isArray(schema.type)
+ ? schema.type.join(', ')
+ : schema.type ?? 'any',
+ [ojp]: schemaPath,
+ };
+ }
+ }
+}
+
+export function endpointToInternal(
+ swaggerEndpoint: FlatOpenAPIV2.OperationObject,
+ { path, method }: { path: string; method: string }
+): InternalSpecEndpoint {
+ let {
+ produces,
+ consumes,
+ parameters,
+ summary,
+ description,
+ responses,
+ ...rest
+ } = swaggerEndpoint;
+ parameters = parameters ?? [];
+ produces = produces ?? [];
+ consumes = consumes ?? [];
+
+ const internalParameters: Record = {};
+ const internalResponses: Record = {};
+ let internalRequestBody: InternalSpecRequestBody | undefined = undefined;
+ const baseEndpointPath = jsonPointerHelpers.compile(['paths', path, method]);
+
+ // Handle regular paramters
+ const formParams: [number, FlatOpenAPIV2.Parameter][] = [];
+ for (let i = 0; i < parameters.length; i++) {
+ let parameter = parameters[i];
+ const parameterPath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'parameters',
+ String(i)
+ );
+ if (parameter.in === 'body') {
+ parameter = parameter as FlatOpenAPIV2.InBodyParameterObject;
+ const { in: paramIn, description, schema, ...rest } = parameter;
+ const internalSchema = schemaToInternal(
+ schema,
+ jsonPointerHelpers.append(parameterPath, 'schema')
+ );
+ const internalContent: InternalSpecContent = {};
+ for (const contentType of consumes.filter(
+ (c) => !FORM_CONTENT_TYPES.has(c)
+ ))
+ internalContent[contentType] = internalSchema;
+ internalRequestBody = {
+ required: parameter.required ?? false,
+ description,
+ content: internalContent,
+ misc: rest,
+ [ojp]: parameterPath,
+ };
+ } else if (parameter.in === 'formData') {
+ // This is handled elsewhere since we need to collect all form types
+ formParams.push([i, parameter]);
+ continue;
+ } else {
+ parameter = parameter as FlatOpenAPIV2.GeneralParameterObject;
+
+ const {
+ in: paramIn,
+ description,
+ required,
+ name,
+ type,
+ items,
+ ...rest
+ } = parameter;
+ const schema = {
+ type,
+ items,
+ };
+ const key = getParameterKey(name, paramIn);
+ internalParameters[key] = {
+ name,
+ in: paramIn,
+ description,
+ required: required ?? false,
+ schema: schemaToInternal(schema, parameterPath),
+ misc: rest,
+ [ojp]: parameterPath,
+ };
+ }
+ }
+ // Handle form parameters - need to collect all form parameters to make a single schema
+ if (formParams.length > 0) {
+ const parametersPath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'parameters'
+ );
+ const formSchema: Extract<
+ InternalSpecSchema,
+ { polymorphicKey: null; type: 'object' }
+ > = {
+ polymorphicKey: null,
+ type: 'object',
+ value: 'object',
+ examples: [],
+ properties: {},
+ misc: {},
+ [ojp]: parametersPath,
+ };
+ for (const [idx, formParam] of formParams) {
+ const { in: paramIn, name, required, type, items, ...rest } = formParam;
+ const internalSchema = schemaToInternal(
+ {
+ type,
+ items,
+ },
+ jsonPointerHelpers.append(parametersPath, String(idx))
+ );
+ formSchema.properties[name] = {
+ key: name,
+ required: required ?? false,
+ ...internalSchema,
+ misc: {
+ ...internalSchema.misc,
+ ...rest,
+ },
+ };
+ }
+ if (!internalRequestBody) {
+ internalRequestBody = {
+ required: formParams.some(([, p]) => p.required),
+ description,
+ content: {},
+ misc: rest,
+ [ojp]: parametersPath,
+ };
+ }
+ for (const contentType of consumes.filter((c) => FORM_CONTENT_TYPES.has(c)))
+ internalRequestBody.content[contentType] = formSchema;
+ }
+
+ for (const [statusCode, response] of Object.entries(responses ?? {})) {
+ if (response) {
+ const baseResponsePath = jsonPointerHelpers.append(
+ baseEndpointPath,
+ 'responses',
+ statusCode
+ );
+ const { headers, description, schema, examples, ...rest } = response;
+ const internalHeaders: InternalSpecResponse['headers'] = {};
+ const internalContent: InternalSpecContent = {};
+
+ for (const [name, header] of Object.entries(headers ?? {})) {
+ const jsonPath = jsonPointerHelpers.append(
+ baseResponsePath,
+ 'headers',
+ name
+ );
+
+ internalHeaders[name] = {
+ name,
+ required: false,
+ schema: schemaToInternal(header, jsonPath),
+ in: 'header',
+ [ojp]: jsonPath,
+ misc: {},
+ };
+ }
+
+ if (schema) {
+ const internalSchema = schemaToInternal(
+ schema,
+ jsonPointerHelpers.append(baseResponsePath, 'schema')
+ );
+ if (examples) {
+ internalSchema.examples.push(...Object.values(examples));
+ }
+ for (const contentType of produces)
+ internalContent[contentType] = internalSchema;
+ }
+
+ internalResponses[statusCode] = {
+ description,
+ content: internalContent,
+ headers: internalHeaders,
+ misc: rest,
+ [ojp]: baseResponsePath,
+ };
+ }
+ }
+
+ return {
+ path,
+ method,
+ summary,
+ description,
+ parameters: internalParameters,
+ requestBody: internalRequestBody,
+ responses: internalResponses,
+ misc: rest,
+ [ojp]: baseEndpointPath,
+ };
+}
+
+export function specToInternal(
+ swaggerSpec: FlatOpenAPIV2.Document
+): InternalSpec {
+ const {
+ paths,
+ parameters,
+ responses,
+ definitions,
+ produces,
+ consumes,
+ swagger,
+ info,
+ tags,
+ host,
+ basePath,
+ externalDocs,
+ security,
+ 'x-optic-ci-empty-spec': _,
+ ...rest
+ } = swaggerSpec as FlatOpenAPIV2.Document & {
+ 'x-optic-ci-empty-spec'?: string;
+ };
+ const metadata: InternalSpecMetadata = {
+ version: swagger,
+ servers: {},
+ info,
+ tags,
+ externalDocs,
+ security,
+ [ojp]: jsonPointerHelpers.compile(['/']),
+ misc: rest,
+ };
+ if (host || basePath) {
+ const url = (host || basePath)!;
+ metadata.servers[url] = {
+ host,
+ basePath,
+ };
+ }
+
+ const endpoints: InternalSpec['endpoints'] = {};
+ for (const [path, pathObj] of Object.entries(paths ?? {})) {
+ for (const method of SWAGGER2_HTTP_METHODS) {
+ const endpoint = pathObj?.[method];
+ const normalized = normalizeOpenApiPath(path);
+ if (endpoint) {
+ endpoints[getOperationId({ method, pathPattern: normalized })] =
+ endpointToInternal(endpoint, { path, method });
+ }
+ }
+ }
+ return { endpoints, metadata };
+}
diff --git a/projects/optic/web/src/app/utils/types.ts b/projects/optic/web/src/app/utils/types.ts
new file mode 100644
index 0000000000..7e69d06f3f
--- /dev/null
+++ b/projects/optic/web/src/app/utils/types.ts
@@ -0,0 +1,121 @@
+import type { RuleResult } from '@useoptic/openapi-utilities';
+import type { OpticDiffs, WithOpticDiffs, od, or } from './changelog-tree';
+import type { ojp } from './utils';
+
+export const UnnamedPolymorphic = Symbol.for('unnamed_polymorphic');
+
+// Types for internal spec format
+export type InternalSpec = {
+ metadata: InternalSpecMetadata;
+ endpoints: WithOpticDiffs>;
+};
+
+export type InternalSpecMetadata = {
+ version: string;
+ servers: WithOpticDiffs>>;
+ info: WithOpticDiffs>;
+ tags?: unknown;
+ externalDocs?: unknown;
+ security?: unknown;
+
+ [ojp]: string;
+ [od]?: OpticDiffs;
+ [or]?: RuleResult[];
+ misc: WithOpticDiffs>;
+};
+
+export type InternalSpecEndpoint = {
+ method: string;
+ path: string;
+ summary?: string;
+ description?: string;
+
+ // Keyed by parameter + location
+ parameters: WithOpticDiffs>;
+ requestBody?: InternalSpecRequestBody;
+ responses: WithOpticDiffs>;
+
+ [ojp]: string;
+ [od]?: OpticDiffs;
+ [or]?: RuleResult[];
+ misc: Record;
+};
+
+export type InternalSpecRequestBody = {
+ required: boolean;
+ description?: string;
+ content: WithOpticDiffs;
+
+ [ojp]: string;
+ [od]?: OpticDiffs;
+ [or]?: RuleResult[];
+ misc: WithOpticDiffs>;
+};
+
+export type InternalSpecResponse = {
+ description: string;
+ content: WithOpticDiffs;
+ headers: WithOpticDiffs>;
+
+ [ojp]: string;
+ [od]?: OpticDiffs;
+ [or]?: RuleResult[];
+ misc: WithOpticDiffs>;
+};
+
+export type InternalSpecParameter = {
+ name: string;
+ in: string;
+ required: boolean;
+ description?: string;
+ schema?: InternalSpecSchema;
+
+ [ojp]: string;
+ [od]?: OpticDiffs;
+ [or]?: RuleResult[];
+ misc: WithOpticDiffs>;
+};
+
+// Keyed by content type -> body
+export type InternalSpecContent = Record;
+
+export type InternalSpecObject = {
+ type: 'object';
+ value: 'object';
+ properties: WithOpticDiffs>;
+ additionalProperties?: boolean | InternalSpecSchema;
+};
+
+export type InternalSpecArray = {
+ type: 'array';
+ value: 'array';
+ items: InternalSpecSchema;
+};
+
+export type InternalSpecPrimitive = {
+ type: 'primitive';
+ value: string; // e.g. boolean, string, number, null, etc
+};
+
+export type InternalSpecSchema = (
+ | ({
+ polymorphicKey: null;
+ } & (InternalSpecObject | InternalSpecArray | InternalSpecPrimitive))
+ | {
+ polymorphicKey: string | typeof UnnamedPolymorphic; // e.g. oneOf, anyOf, typeArrays
+ schemas: InternalSpecSchema[];
+ }
+) & {
+ title?: string;
+ description?: string;
+ examples: any[];
+ [ojp]: string;
+ [od]?: OpticDiffs;
+ [or]?: RuleResult[];
+ misc: WithOpticDiffs>;
+};
+
+export type InternalSpecSchemaField = InternalSpecSchema & {
+ key: string;
+ required: boolean;
+};
diff --git a/projects/optic/web/src/app/utils/utils.ts b/projects/optic/web/src/app/utils/utils.ts
new file mode 100644
index 0000000000..2964cc46b0
--- /dev/null
+++ b/projects/optic/web/src/app/utils/utils.ts
@@ -0,0 +1,40 @@
+import { anyChangelog } from './all-items';
+import type { InternalSpecSchema } from './types';
+import type { Changelog } from './changelog-tree';
+import { od } from './changelog-tree';
+
+export const ojp = Symbol.for('original_json_path');
+
+export function getParameterKey(name: string, type: string): string {
+ return `${type}: ${name}`;
+}
+
+export function splitParameterKey(key: string): { name: string; type: string } {
+ const [type, name] = key.split(': ');
+ return { type, name };
+}
+
+export function getPolymorphicKeyChangelog(
+ schema: InternalSpecSchema
+): Changelog | undefined {
+ // Check for nonpolymorphic -> polymorphic
+ const changelog = anyChangelog(schema[od], 'polymorphicKey');
+ if (changelog?.type === 'changed') {
+ return {
+ type: 'changed',
+ before:
+ changelog.before === null
+ ? schema[od]?.removed?.type?.before === 'primitive'
+ ? schema[od]?.removed?.value?.before
+ : schema[od]?.removed?.type?.before
+ : changelog.before,
+ };
+ } else if (changelog?.type === 'removed' && schema.polymorphicKey === null) {
+ return {
+ type: 'changed',
+ before: schema.type === 'primitive' ? schema.value : schema.type,
+ };
+ }
+
+ return undefined;
+}
diff --git a/projects/optic/web/src/index.tsx b/projects/optic/web/src/index.tsx
new file mode 100644
index 0000000000..674e95af59
--- /dev/null
+++ b/projects/optic/web/src/index.tsx
@@ -0,0 +1,51 @@
+import { useMemo } from 'react';
+import ReactDOM from 'react-dom';
+import { ChangelogPage } from './app/ChangelogPage';
+import { ThemeProvider } from '@mui/system';
+import theme from './app/constants';
+import { Buffer } from 'buffer';
+// @ts-ignore
+import decompress from 'brotli/decompress';
+import { specToInternalInferVersion } from './app/utils';
+
+const decodeHash = (data: string): any => {
+ return JSON.parse(
+ Buffer.from(decompress(Buffer.from(data, 'base64'))).toString()
+ );
+};
+
+const App = () => {
+ const transformed = useMemo(() => {
+ const decoded = decodeHash(window.location.hash);
+ return {
+ ...decoded,
+ base: {
+ original: decoded.base,
+ internal: specToInternalInferVersion(decoded.base),
+ },
+ head: {
+ original: decoded.head,
+ internal: specToInternalInferVersion(decoded.head),
+ },
+ };
+ }, []);
+
+ return (
+
+
+
+
+
+ );
+};
+
+ReactDOM.render(, document.getElementById('root') as HTMLElement);
diff --git a/projects/optic/web/tsconfig.json b/projects/optic/web/tsconfig.json
new file mode 100644
index 0000000000..fba2f3a06c
--- /dev/null
+++ b/projects/optic/web/tsconfig.json
@@ -0,0 +1,21 @@
+{
+ "compilerOptions": {
+ "target": "es5",
+ "lib": ["dom", "dom.iterable", "esnext"],
+ "allowJs": true,
+ "skipLibCheck": true,
+ "esModuleInterop": true,
+ "allowSyntheticDefaultImports": true,
+ "strict": true,
+ "forceConsistentCasingInFileNames": true,
+ "noFallthroughCasesInSwitch": true,
+ "module": "esnext",
+ "moduleResolution": "node",
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+ "downlevelIteration": true,
+ "jsx": "react-jsx"
+ },
+ "include": ["src"]
+}