feat: Refactor SchemaControler to make it stateless - fixed curcular dependencies

Author: pzawadzki-pronos

src/Adapters/Schema/InMemorySchemaCache.js

@@ -1,26 +1,18 @@
-import type { Schema } from '../../Controllers/types';
-import { SchemaData } from '../../Controllers/SchemaController';
+import { SchemaAndData } from './types';
 
 export default class InMemorySchemaCache {
-  dataProvider: () => Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }>;
   fetchingSchemaPromise: any;
   cache = {};
 
-  setDataProvider(
-    dataProvider: () => Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }>
-  ) {
-    this.dataProvider = dataProvider;
-  }
-
-  async fetchSchema(): Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }> {
+  async fetchSchema(getDataFromDb: () => Promise<SchemaAndData>): Promise<SchemaAndData> {
     if (this.cache.isCached) {
       return {
         allClasses: this.cache.allClasses,
         schemaData: this.cache.schemaData,
       };
     }
     if (!this.fetchingSchemaPromise) {
-      this.fetchingSchemaPromise = this.dataProvider();
+      this.fetchingSchemaPromise = await getDataFromDb();
     }
     const result = await this.fetchingSchemaPromise;
     this.cache.isCached = true;

src/Adapters/Schema/SchemaCacheAccess.js

@@ -3,25 +3,39 @@
  * @module Adapters
  */
 import type { Schema } from '../../Controllers/types';
-import { SchemaData } from '../../Controllers/SchemaController';
 import SchemaCacheAdapter from './SchemaCacheAdapter';
+import { injectDefaultSchema, SchemaData } from '../../Schema/SchemaData';
+import { StorageAdapter } from '../Storage/StorageAdapter';
+import type { ParseServerOptions } from '../../Options';
+import { SchemaAndData } from './types';
 
 /**
  * @interface SchemaCacheAccess
  */
 export class SchemaCacheAccess {
-  constructor(schemaCacheAdapter: SchemaCacheAdapter) {
+  schemaCacheAdapter: SchemaCacheAdapter;
+  dbAdapter: StorageAdapter;
+  protectedFields: any;
+
+  constructor(schemaCacheAdapter: SchemaCacheAdapter, dbAdapter, options: ParseServerOptions) {
     this.schemaCacheAdapter = schemaCacheAdapter;
+    this.dbAdapter = dbAdapter;
+    this.protectedFields = options ? options.protectedFields : undefined;
   }
 
-  setDataProvider(
-    dataProvider: () => Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }>
-  ) {
-    this.schemaCacheAdapter.setDataProvider(dataProvider);
-  }
+  async getSchemaAndData(): Promise<SchemaAndData> {
+    const that = this;
+    return this.schemaCacheAdapter.fetchSchema(async () => {
+      const rawAllSchemas = await that.dbAdapter.getAllClasses();
+      const allSchemas = rawAllSchemas.map(injectDefaultSchema);
+
+      const schemaData = new SchemaData(allSchemas, that.protectedFields);
 
-  async getSchemaAndData(): Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }> {
-    return this.schemaCacheAdapter.fetchSchema();
+      return {
+        schemaData,
+        allClasses: allSchemas,
+      };
+    });
   }
 
   async all(): Promise<Array<Schema>> {
@@ -37,7 +51,7 @@ export class SchemaCacheAccess {
   }
 
   clear(): Promise<void> {
-    this.schemaCacheAdapter.clear();
+    return this.schemaCacheAdapter.clear();
   }
 
   async getSchemaData(): Promise<SchemaData> {

src/Adapters/Schema/SchemaCacheAdapter.js

@@ -2,24 +2,16 @@
 /**
  * @module Adapters
  */
-import type { Schema } from '../../Controllers/types';
-import { SchemaData } from '../../Controllers/SchemaController';
+import { SchemaAndData } from './types';
 
 /**
  * @interface SchemaCacheAdapter
  */
 export default class SchemaCacheAdapter {
-  /**
-   * Used by controller to provide data from database
-   */
-  setDataProvider(
-    dataProvider: () => Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }>
-  ) {}
-
   /**
    * Get all schema entries and its corresponding intermediate format
    */
-  async fetchSchema(): Promise<{ allClasses: Array<Schema>, schemaData: SchemaData }> {}
+  async fetchSchema(getDataFromDb: () => Promise<SchemaAndData>): Promise<SchemaAndData> {}
 
   /**
    * Clear cache

src/Adapters/Schema/types.js

@@ -0,0 +1,7 @@
+import type { Schema } from '../../Controllers/types';
+import { SchemaData } from '../../Schema/SchemaData';
+
+export type SchemaAndData = {
+  allClasses: Array<Schema>,
+  schemaData: SchemaData,
+};

src/Controllers/DatabaseController.js

@@ -364,7 +364,7 @@ const relationSchema = {
 class DatabaseController {
   adapter: StorageAdapter;
   schemaCache: SchemaCacheAccess;
-  schemaController: SchemaController;
+  schemaController: any;
   _transactionalSession: ?any;
   options: ParseServerOptions;
   idempotencyOptions: any;
@@ -375,7 +375,8 @@ class DatabaseController {
     options: ParseServerOptions
   ) {
     this.adapter = adapter;
-    this.schemaCache = schemaCache || new InMemorySchemaCache();
+    this.schemaCache =
+      schemaCache || new SchemaCacheAccess(new InMemorySchemaCache(), adapter, options);
     this.options = options || {};
     this.idempotencyOptions = this.options.idempotencyOptions || {};
     // Prevent mutable this.schema, otherwise one request could use
@@ -386,7 +387,6 @@ class DatabaseController {
       this.schemaCache,
       this.options
     );
-    this.schemaCache.setDataProvider(() => this.schemaController.getSchemaObjects());
   }
 
   collectionExists(className: string): Promise<boolean> {
@@ -891,9 +891,8 @@ class DatabaseController {
    * @param {boolean} fast set to true if it's ok to just delete rows and not indexes
    * @returns {Promise<void>} when the deletions completes
    */
-  deleteEverything(fast: boolean = false): Promise<any> {
-    this.schemaPromise = null;
-    this.schemaCache.clear();
+  async deleteEverything(fast: boolean = false): Promise<any> {
+    await this.schemaCache.clear();
     return this.adapter.deleteAllClasses(fast);
   }