@fibery/schema 8.4.0 → 10.0.0

package/lib/src/type-object.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeObject = void 0;
+/* eslint-disable no-use-before-define */
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("./utils");
+const pluralize_1 = __importDefault(require("pluralize"));
+class TypeObject {
+    name;
+    description;
+    id;
+    rawMeta;
+    isDomain;
+    isPlatform;
+    isHighlight;
+    isMixin;
+    mixinIcon;
+    isEnum;
+    isPrimitive;
+    isWriterModeByDefault;
+    nameParts;
+    color;
+    units;
+    installedMixins;
+    syncSource;
+    version;
+    installedMixinTypeObjects;
+    title;
+    pluralTitle;
+    fieldObjects;
+    fieldObjectsById;
+    fieldObjectsByName;
+    typeComponentFieldObject;
+    isDeleted;
+    isEntityRef;
+    constructor({ rawTypeObject, resolveTypeObject, getTypeComponentTypeToFieldObject, version, factory, resolveMultiRelatedFieldObjects, }) {
+        if (!lodash_1.default.isPlainObject(rawTypeObject)) {
+            throw new Error("rawTypeObject arg must be plain object");
+        }
+        if (!lodash_1.default.isFunction(resolveTypeObject)) {
+            throw new Error("resolveTypeObject arg must be function");
+        }
+        this.name = rawTypeObject["fibery/name"];
+        this.description = rawTypeObject["fibery/description"] || null;
+        this.id = rawTypeObject["fibery/id"];
+        const rawMeta = rawTypeObject["fibery/meta"] || {};
+        this.rawMeta = rawMeta;
+        this.isDomain = rawMeta["fibery/domain?"] || false;
+        this.isPlatform = rawMeta["fibery/platform?"] || false;
+        this.isHighlight = rawMeta["fibery/highlight?"] || false;
+        this.isMixin = rawMeta["app/mixin?"] || false;
+        this.mixinIcon = rawMeta["ui/mixin-icon"] || null;
+        this.isEnum = rawMeta["fibery/enum?"] || false;
+        this.isPrimitive = rawMeta["fibery/primitive?"] || false;
+        this.isWriterModeByDefault = rawMeta["ui/writer-mode?"] || false;
+        this.isDeleted = rawTypeObject["fibery/deleted?"] || false;
+        this.nameParts = (0, utils_1.parseType)(this.name);
+        this.color = rawMeta["ui/color"] || "#4568FB";
+        this.units = rawMeta["ui/units"] || null;
+        this.installedMixins = new Set(Object.keys(rawMeta["app/mixins"] || {}));
+        this.syncSource = rawMeta["sync/source"] || null;
+        this.version = version;
+        this.isEntityRef = rawTypeObject["fibery/name"] === "fibery/entity-ref";
+        const fieldObjectsByNameOnceGetter = lodash_1.default.once(() => {
+            return factory.makeFieldObjectsByName({
+                type: this.name,
+                fieldObjects: this.fieldObjects,
+            });
+        });
+        const fieldObjectsGetter = lodash_1.default.once(() => rawTypeObject["fibery/fields"].map((rawFieldObject) => {
+            return factory.makeFieldObject({
+                rawFieldObject,
+                holderType: this.name,
+                resolveTypeObject,
+                version,
+                resolveMultiRelatedFieldObjects,
+            });
+        }));
+        Object.defineProperties(this, {
+            toJSON: {
+                value() {
+                    if (process.env.NODE_ENV === "test") {
+                        return `<schema.typeObjectsByName["${rawTypeObject["fibery/name"]}"]>`;
+                    }
+                    return rawTypeObject;
+                },
+                enumerable: false,
+            },
+            fieldObjects: {
+                configurable: false,
+                enumerable: true,
+                get: fieldObjectsGetter,
+            },
+            typeComponentFieldObject: {
+                configurable: false,
+                enumerable: true,
+                get: () => {
+                    return getTypeComponentTypeToFieldObject(this.name);
+                },
+            },
+            fieldObjectsById: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => {
+                    return factory.makeFieldObjectsById({
+                        type: this.name,
+                        fieldObjects: this.fieldObjects,
+                    });
+                }),
+            },
+            fieldObjectsByName: {
+                configurable: false,
+                enumerable: true,
+                get: fieldObjectsByNameOnceGetter,
+            },
+            installedMixinTypeObjects: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => [...this.installedMixins].map(resolveTypeObject).filter((typeObject) => typeObject)),
+            },
+            title: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => (0, utils_1.toTitle)(this.name)),
+            },
+            pluralTitle: {
+                configurable: false,
+                enumerable: true,
+                get: lodash_1.default.once(() => (0, utils_1.toTitle)(pluralize_1.default.plural(this.name))),
+            },
+        });
+    }
+    _getFieldObjectShortcuts = lodash_1.default.once(() => {
+        const hasRank = this.installedMixins.has("fibery/rank-mixin");
+        return this.fieldObjects.reduce((result, fieldObject) => {
+            if (fieldObject.isId) {
+                result.idField = fieldObject.name;
+                result.idFieldObject = fieldObject;
+            }
+            else if (fieldObject.isPublicId) {
+                result.publicIdField = fieldObject.name;
+                result.publicIdFieldObject = fieldObject;
+            }
+            else if (fieldObject.isTitle) {
+                result.titleField = fieldObject.name;
+                result.titleFieldObject = fieldObject;
+            }
+            else if (hasRank && fieldObject.name === "fibery/rank") {
+                result.rankField = fieldObject.name;
+                result.rankFieldObject = fieldObject;
+            }
+            return result;
+        }, {
+            idField: null,
+            idFieldObject: null,
+            publicIdField: null,
+            publicIdFieldObject: null,
+            titleField: null,
+            titleFieldObject: null,
+            rankField: null,
+            rankFieldObject: null,
+        });
+    });
+    get idField() {
+        return this._getFieldObjectShortcuts().idField;
+    }
+    get idFieldObject() {
+        return this._getFieldObjectShortcuts().idFieldObject;
+    }
+    get publicIdField() {
+        return this._getFieldObjectShortcuts().publicIdField;
+    }
+    get publicIdFieldObject() {
+        return this._getFieldObjectShortcuts().publicIdFieldObject;
+    }
+    get titleField() {
+        return this._getFieldObjectShortcuts().titleField;
+    }
+    get titleFieldObject() {
+        return this._getFieldObjectShortcuts().titleFieldObject;
+    }
+    get rankField() {
+        return this._getFieldObjectShortcuts().rankField;
+    }
+    get rankFieldObject() {
+        return this._getFieldObjectShortcuts().rankFieldObject;
+    }
+}
+exports.TypeObject = TypeObject;

package/lib/src/utils.d.ts

@@ -0,0 +1,59 @@
+import _ from "lodash";
+import { RawSchema } from "./schema";
+export declare const withOnlyDefinedGets: (target: any, targetKind?: string) => any;
+export declare const capitalizeFirstChar: (input: string) => string;
+export declare const toTypeOrFieldNamePartTitle: (str: string) => string;
+export declare const toTypeOrFieldTitle: (str: string) => string;
+export declare const toPascalCase: (lispCasedString?: string) => string;
+export declare const toNonEnumTitle: (str: string) => string;
+export declare const parseEnumType: (type: string) => {
+    templateName: string;
+    templateNamespace: string;
+    targetName: string;
+    targetNamespace: string;
+};
+export declare const toTitle: (typeOrAttr: string) => string;
+export declare const parseType: ((type: any) => {
+    namespace: string;
+    name: string;
+}) & _.MemoizedFunction;
+export declare const makeEnumTypeNamePart: ({ holderType, enumName }: {
+    holderType: string;
+    enumName: string;
+}) => string;
+export declare const attachEnumNamespace: ({ enumNamespace, typeNamePart }: {
+    enumNamespace: string;
+    typeNamePart: string;
+}) => string;
+export declare const removeDeletedTypesAndFields: (rawSchema: RawSchema) => {
+    "fibery/types": {
+        "fibery/fields": import("./field-object").RawFieldObject[];
+        "fibery/id": string;
+        "fibery/name": string;
+        "fibery/description"?: string | null | undefined;
+        "fibery/deleted?"?: boolean | undefined;
+        "fibery/meta": {
+            "fibery/domain?"?: boolean | undefined;
+            "fibery/platform?"?: boolean | undefined;
+            "fibery/highlight?"?: boolean | undefined;
+            "app/mixin?"?: boolean | undefined;
+            "ui/mixin-icon"?: string | undefined;
+            "fibery/enum?"?: boolean | undefined;
+            "fibery/primitive?"?: boolean | undefined;
+            "ui/writer-mode?"?: boolean | undefined;
+            "ui/color"?: string | undefined;
+            "ui/units"?: unknown[] | undefined;
+            "app/mixins"?: Record<string, boolean> | undefined;
+            "sync/source"?: {
+                appId: string;
+                appName: string;
+                id: string;
+                state: string;
+                type: string;
+            } | undefined;
+            "fibery/secured?"?: boolean | undefined;
+        };
+    }[];
+    "fibery/id": string;
+    "fibery/version": string;
+};

package/lib/src/utils.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDeletedTypesAndFields = exports.attachEnumNamespace = exports.makeEnumTypeNamePart = exports.parseType = exports.toTitle = exports.parseEnumType = exports.toNonEnumTitle = exports.toPascalCase = exports.toTypeOrFieldTitle = exports.toTypeOrFieldNamePartTitle = exports.capitalizeFirstChar = exports.withOnlyDefinedGets = void 0;
+const trace_1 = require("@fibery/helpers/utils/trace");
+const lodash_1 = __importDefault(require("lodash"));
+const errors_1 = require("./errors");
+const print_utils_1 = require("./print-utils");
+const jestKey = new Set(["nodeType", "tagName", "hasAttribute"]);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const withOnlyDefinedGets = (target, targetKind = "object") => new Proxy(target, {
+    get(target, key) {
+        if (!(key in target) && process.env.NODE_ENV !== "production") {
+            if (key === "__target__") {
+                return target;
+            }
+            if (key === "_reactFragment") {
+                // greetings from react-developer-tools
+                return undefined;
+            }
+            if (key === "_error") {
+                // greetings from redux-form.deepEqual
+                return undefined;
+            }
+            if (key === "_warning") {
+                // greetings from redux-form.deepEqual
+                return undefined;
+            }
+            if (key === "length") {
+                // greetings from lodash isArrayLike
+                return undefined;
+            }
+            if (key === "inspect") {
+                // greetings from jest console implementation
+                return undefined;
+            }
+            if (key === "@@toStringTag") {
+                // greetings from prop-types isSymbol
+                return undefined;
+            }
+            if (key === "$$typeof") {
+                // greetings from react-developer-tools
+                return undefined;
+            }
+            if (process.env.NODE_ENV === "test") {
+                // greetings from jest
+                if (typeof key === "string" && jestKey.has(key)) {
+                    return undefined;
+                }
+                if (key === "@@__IMMUTABLE_ITERABLE__@@") {
+                    return undefined;
+                }
+                if (key === "@@__IMMUTABLE_RECORD__@@") {
+                    return undefined;
+                }
+                if (key === "_isMockFunction") {
+                    return undefined;
+                }
+                if (key === "asymmetricMatch") {
+                    // greetings from jest expect().toEqual
+                    return undefined;
+                }
+                if (key === "then") {
+                    // Promise.resolve(schema)
+                    return undefined;
+                }
+                if (key === "toJSON") {
+                    return () => "<" + targetKind + ">";
+                }
+            }
+            if (typeof key === "symbol") {
+                // greetings from Object.prototype.toString (Symbol.toStringTag), from react-developer-tools (Symbol.iterator)
+                return undefined;
+            }
+            throw new errors_1.NotDefinedGetError(`${targetKind}${(0, print_utils_1.printJsPath)([key])} is undefined`);
+        }
+        return target[key];
+    },
+});
+exports.withOnlyDefinedGets = withOnlyDefinedGets;
+const getNamePart = (str) => splitKeyword(str).name;
+const capitalizeFirstChar = (input) => {
+    const str = input || "";
+    return str ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+};
+exports.capitalizeFirstChar = capitalizeFirstChar;
+const replaceTildes = (str) => (str || "").split("~").join(" ");
+exports.toTypeOrFieldNamePartTitle = lodash_1.default.flow([exports.capitalizeFirstChar, replaceTildes]);
+exports.toTypeOrFieldTitle = lodash_1.default.flow([getNamePart, exports.toTypeOrFieldNamePartTitle]);
+const toPascalCase = (lispCasedString = "") => lispCasedString && (lodash_1.default.last(lispCasedString.split("/")) || "").split("-").map(lodash_1.default.capitalize).join(" ");
+exports.toPascalCase = toPascalCase;
+const isObsoleteTitle = (str) => {
+    const { name } = splitKeyword(str);
+    return name.toLowerCase() === name && !hasTildes(name);
+};
+const hasTildes = (str) => str.includes("~");
+const toNonEnumTitle = (str) => {
+    return isObsoleteTitle(str) ? (0, exports.toPascalCase)(str) : (0, exports.toTypeOrFieldTitle)(str);
+};
+exports.toNonEnumTitle = toNonEnumTitle;
+const parseEnumType = (type) => {
+    const [templateType, targetType] = type.split("_");
+    const { name: templateName, namespace: templateNamespace } = (0, exports.parseType)(templateType);
+    const { name: targetName, namespace: targetNamespace } = (0, exports.parseType)(targetType);
+    return { templateName, templateNamespace, targetName, targetNamespace };
+};
+exports.parseEnumType = parseEnumType;
+const toEnumTitle = (type) => {
+    // enum logic
+    const { templateName, targetName } = (0, exports.parseEnumType)(type);
+    return (0, exports.toTitle)(targetName) + " " + (0, exports.toTitle)(templateName);
+};
+const toTitle = (typeOrAttr) => {
+    const str = typeOrAttr || "";
+    return str.includes("_") ? toEnumTitle(str) : (0, exports.toNonEnumTitle)(str);
+};
+exports.toTitle = toTitle;
+const splitKeyword = (keyword) => {
+    const str = keyword || "";
+    const index = str.indexOf("/");
+    if (index === -1) {
+        return {
+            namespace: "",
+            name: str,
+        };
+    }
+    const namespace = str.substring(0, index);
+    const name = str.substring(index + 1);
+    return {
+        namespace,
+        name,
+    };
+};
+exports.parseType = lodash_1.default.memoize((type) => {
+    if (!type.includes("/")) {
+        (0, trace_1.traceError)(`parseType invalid usage: passed type is '${type}'`);
+    }
+    return splitKeyword(type);
+});
+const makeEnumTypeNamePart = ({ holderType, enumName }) => {
+    const { namespace, name } = (0, exports.parseType)(holderType);
+    return `${enumName}_${namespace}/${name}`;
+};
+exports.makeEnumTypeNamePart = makeEnumTypeNamePart;
+const attachEnumNamespace = ({ enumNamespace, typeNamePart }) => {
+    return `${enumNamespace}/${typeNamePart}`;
+};
+exports.attachEnumNamespace = attachEnumNamespace;
+const removeDeletedTypesAndFields = (rawSchema) => {
+    const { "fibery/types": rawTypeObjects, ...schemaRest } = rawSchema;
+    const filteredRawTypeObjects = rawTypeObjects
+        .filter((rawTypeObject) => rawTypeObject["fibery/deleted?"] !== true)
+        .map((rawTypeObject) => {
+        const { "fibery/fields": rawFieldObjects, ...rawTypeObjectRest } = rawTypeObject;
+        const filteredRawFieldObjects = rawFieldObjects.filter((rawFieldObject) => rawFieldObject["fibery/deleted?"] !== true);
+        return { ...rawTypeObjectRest, "fibery/fields": filteredRawFieldObjects };
+    });
+    return { ...schemaRest, "fibery/types": filteredRawTypeObjects };
+};
+exports.removeDeletedTypesAndFields = removeDeletedTypesAndFields;

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@fibery/schema",
-  "version": "8.4.0",
-  "description": "utils for working with fibery schema",
+  "version": "10.0.0",
+  "description": "Fibery schema utils",
   "main": "./lib/index.js",
-  "browser": "./index.js",
-  "types": "./types.d.ts",
   "files": [
-    "./lib",
-    "types.d.ts"
+    "./lib"
   ],
   "private": false,
   "dependencies": {
@@ -18,15 +15,18 @@
   },
   "devDependencies": {
     "@babel/core": "7.20.5",
+    "@swc/jest": "0.2.29",
     "@types/lodash": "4.14.172",
-    "babel-jest": "27.5.1",
+    "@types/node": "18.11.17",
+    "@types/pluralize": "0.0.29",
     "babel-loader": "9.1.0",
     "jest": "27.5.1",
     "jest-junit": "13.0.0",
+    "typescript": "5.1.6",
     "webpack": "5.87.0",
     "webpack-cli": "4.10.0",
-    "@fibery/eslint-config": "8.5.0",
-    "@fibery/babel-preset": "7.3.0"
+    "@fibery/babel-preset": "7.3.0",
+    "@fibery/eslint-config": "8.5.0"
   },
   "jest": {
     "testEnvironment": "node",
@@ -45,13 +45,30 @@
       "<rootDir>[/\\\\](build|docs|node_modules|scripts)[/\\\\]"
     ],
     "transform": {
-      "^.+\\.(js|jsx|ts|tsx)$": "../../fibery-ui/config/jest/babel.js"
+      "^.+\\.(js|jsx|ts|tsx)$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "tsx": true,
+              "decorators": true,
+              "dynamicImport": true
+            },
+            "transform": {
+              "react": {
+                "runtime": "automatic"
+              }
+            }
+          }
+        }
+      ]
     },
     "testURL": "http://localhost"
   },
   "scripts": {
-    "build": "BABEL_ENV=production webpack",
-    "test": "node scripts/test.js",
+    "build": "rm -rf lib && pnpm exec tsc --project tsconfig.build.json",
+    "test": "jest",
     "test:ci": "pnpm run test --reporters=default --reporters=jest-junit",
     "test:coverage": "pnpm run test --coverage --coverageDirectory=${JEST_COVERAGE_RESULT_DIR:-$(pwd)}/coverage/schema --reporters=default --reporters=jest-junit",
     "lint": "eslint ."

package/index.js

@@ -1,61 +0,0 @@
-import _ from "lodash";
-import {FieldObject} from "./FieldObject";
-import {Schema} from "./Schema";
-import {TypeObject} from "./TypeObject";
-import {removeDeletedTypesAndFields, withOnlyDefinedGets} from "./utils";
-
-export const factory = {
-  makeSchema: (rawSchema, options = {shouldRemoveDeletedTypesAndFields: true}) =>
-    new Schema({
-      rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-      factory,
-    }),
-  makeTypeObject: (args) => new TypeObject({...args, factory}),
-  makeTypeObjectsById: (typeObjects) => _.keyBy(typeObjects, (x) => x.id),
-  makeTypeObjectsByName: (typeObjects) => _.keyBy(typeObjects, (x) => x.name),
-  makeFieldObject: (args) => new FieldObject(args),
-  makeFieldObjectsById: ({type, fieldObjects}) => _.keyBy(fieldObjects, (x) => x.id),
-  makeFieldObjectsByName: ({type, fieldObjects}) => _.keyBy(fieldObjects, (x) => x.name),
-};
-
-export const protectiveFactory = {
-  makeSchema: (rawSchema, options = {shouldRemoveDeletedTypesAndFields: true}) =>
-    withOnlyDefinedGets(
-      new Schema({
-        rawSchema: options.shouldRemoveDeletedTypesAndFields ? removeDeletedTypesAndFields(rawSchema) : rawSchema,
-        factory: protectiveFactory,
-      }),
-      `schema`
-    ),
-  makeTypeObject: (args) => {
-    const typeObject = new TypeObject({...args, factory: protectiveFactory});
-    return withOnlyDefinedGets(typeObject, `schema.typeObjectsByName["${typeObject.name}"]`);
-  },
-  makeTypeObjectsById: (typeObjects) =>
-    withOnlyDefinedGets(
-      _.keyBy(typeObjects, (x) => x.id),
-      "schema.typeObjectsById"
-    ),
-  makeTypeObjectsByName: (typeObjects) =>
-    withOnlyDefinedGets(
-      _.keyBy(typeObjects, (x) => x.name),
-      "schema.typeObjectsByName"
-    ),
-  makeFieldObject: (args) => {
-    const fieldObject = new FieldObject(args);
-    return withOnlyDefinedGets(
-      fieldObject,
-      `schema.typeObjectsByName["${fieldObject.holderType}"].fieldObjectsByName["${fieldObject.name}"]`
-    );
-  },
-  makeFieldObjectsById: ({type, fieldObjects}) =>
-    withOnlyDefinedGets(
-      _.keyBy(fieldObjects, (x) => x.id),
-      `schema.typeObjectsByName["${type}"].fieldObjectsById`
-    ),
-  makeFieldObjectsByName: ({type, fieldObjects}) =>
-    withOnlyDefinedGets(
-      _.keyBy(fieldObjects, (x) => x.name),
-      `schema.typeObjectsByName["${type}"].fieldObjectsByName`
-    ),
-};

package/types.d.ts

@@ -1,101 +0,0 @@
-type Cardinality =
-  | ":cardinality/one-to-one"
-  | ":cardinality/one-to-many"
-  | ":cardinality/many-to-many"
-  | ":cardinality/many-to-one";
-export type FieldObject = {
-  name: string;
-  description: string | null;
-  id: string;
-  type: string;
-  rawMeta: Record<string, unknown>;
-  holderType: string;
-  isCollection: boolean;
-  isTitle: boolean;
-  isId: boolean;
-  isPublicId: boolean;
-  isReadOnly: boolean;
-  isFormula: boolean;
-  formula: unknown | null;
-  isLookup: boolean;
-  hasLinkRule: boolean;
-  linkRule: unknown | null;
-  relation: string | null;
-  multiRelation: string | null;
-  defaultValue: unknown | null;
-  objectEditorOrder: number;
-  isRequired: boolean;
-  isHidden: boolean;
-  disableLinkExistingItems: boolean;
-  version: string;
-  // eslint-disable-next-line no-use-before-define
-  typeObject: TypeObject;
-  mixinTypeObject: unknown;
-  // eslint-disable-next-line no-use-before-define
-  holderTypeObject: TypeObject;
-  nameParts: {
-    namespace: string;
-    name: string;
-  };
-  title: string;
-  relatedFieldObject: FieldObject | null;
-  cardinality: Cardinality;
-  kind: ":field/reference" | ":field/reference-collection" | ":field/basic";
-  multiRelatedFieldObjects: Array<FieldObject>;
-};
-
-export type TypeObject = {
-  name: string;
-  description: string | null;
-  id: string;
-  idField: string;
-  idFieldObject: FieldObject;
-  publicIdField: string;
-  publicIdFieldObject: FieldObject;
-  titleField: string;
-  titleFieldObject: FieldObject;
-  rankField: string | null;
-  rawMeta: Record<string, unknown>;
-  isDomain: boolean;
-  isHighlight: boolean;
-  isMixin: boolean;
-  mixinIcon: string | null;
-  isEnum: boolean;
-  isPrimitive: boolean;
-  isRequired: boolean;
-  isWriterModeByDefault: boolean;
-  nameParts: {
-    namespace: string;
-    name: string;
-  };
-  color: string;
-  units: unknown | null;
-  installedMixins: Set<string>;
-  syncSource: {appId: string; appName: string; id: string; state: string; type: string} | null;
-  version: string;
-  installedMixinTypeObjects: unknown;
-  title: string;
-  pluralTitle: string;
-  fieldObjects: Array<FieldObject>;
-  fieldObjectsById: Record<string, FieldObject>;
-  fieldObjectsByName: Record<string, FieldObject>;
-  typeComponentFieldObject: FieldObject | undefined;
-  isDeleted: boolean;
-  isEntityRef: boolean;
-};
-
-export type Schema = {
-  typeObjects: Array<TypeObject>;
-  typeObjectsById: Record<string, TypeObject>;
-  typeObjectsByName: Record<string, TypeObject>;
-  id: string;
-  version: string;
-};
-
-interface Factory {
-  makeSchema: (rawSchema: Record<string, unknown>, options?: {shouldRemoveDeletedTypesAndFields: boolean}) => Schema;
-}
-
-export const factory: Factory;
-
-export const protectiveFactory: Factory;