Register services on orbitRegistry (#434)

* Register services on orbitRegistry

* Fix lint

* Update orbit-registry.ts

* Remove some factories

Author: RobbieTheWagner

README.md

@@ -88,7 +88,6 @@ In a new vite based app, we can use `import.meta.glob` to grab all the things we
 to register and pass them to `setupOrbit. You may want to set this up in your application route's `beforeModel` hook.
 
 ```ts
-import { getOwner } from "@ember/owner";
 import Route from "@ember/routing/route";
 import { service } from "@ember/service";
 import { setupOrbit, type Store } from "ember-orbit";
@@ -109,10 +108,7 @@ export default class ApplicationRoute extends Route {
   @service declare store: Store;
 
   async beforeModel() {
-    const application = getOwner(this);
-
     setupOrbit(
-      application,
       {
         ...dataModels,
         ...dataSources,
@@ -637,7 +633,6 @@ enable the coordinator. Let's do this in our application route's `beforeModel`
 hook (in `app/routes/application.js`):
 
 ```ts
-import { getOwner } from "@ember/owner";
 import Route from "@ember/routing/route";
 import { service } from "@ember/service";
 import { setupOrbit, type Store } from "ember-orbit";
@@ -658,10 +653,7 @@ export default class ApplicationRoute extends Route {
   @service declare store: Store;
 
   async beforeModel() {
-    const application = getOwner(this);
-
     setupOrbit(
-      application,
       {
         ...dataModels,
         ...dataSources,

src/-private/factories/key-map-factory.ts renamed to src/-private/services/data-key-map.ts

@@ -0,0 +1,14 @@
+import {
+  ModelAwareNormalizer,
+  type ModelRecordNormalizerSettings,
+} from '../utils/model-aware-normalizer.ts';
+import { orbitRegistry } from '../utils/orbit-registry.ts';
+
+export default {
+  create(injections: ModelRecordNormalizerSettings): ModelAwareNormalizer {
+    injections.keyMap = orbitRegistry.services.keyMap;
+    injections.schema = orbitRegistry.services.schema;
+
+    return new ModelAwareNormalizer(injections);
+  },
+};

src/-private/services/data-normalizer.ts

@@ -1,86 +1,129 @@
-import type Owner from '@ember/owner';
 import DataSourceStore from '../../data-sources/store.ts';
 import type MemorySourceFactory from '../factories/memory-source-factory.ts';
 import type ModelFactory from '../model-factory.ts';
+import DataKeyMap from '../services/data-key-map.ts';
+import DataNormalizer from '../services/data-normalizer.ts';
+import DataSchema from '../services/data-schema.ts';
+import DataValidator from '../services/data-validator.ts';
 import { getName } from '../utils/get-name.ts';
 import { orbitRegistry } from '../utils/orbit-registry.ts';
 import type { Strategy } from '@orbit/coordinator';
 import type { Bucket } from '@orbit/core';
 import { type MemorySourceSettings } from '@orbit/memory';
 
-type Folder =
-  | '/data-buckets/'
-  | '/data-models/'
-  | '/data-sources/'
-  | '/data-strategies/';
-
 interface FactoryForFolderType {
   '/data-buckets/': { default: { create(): Bucket } };
   '/data-models/': { default: ModelFactory };
   '/data-sources/': { default: typeof MemorySourceFactory };
   '/data-strategies/': { default: { create(): Strategy } };
 }
 
-function injectModules(modules: Record<string, unknown>) {
-  const folderConfig = {
-    '/data-buckets/': { registry: orbitRegistry.registrations.buckets },
-    '/data-models/': { registry: orbitRegistry.registrations.models },
-    '/data-sources/': { registry: orbitRegistry.registrations.sources },
-    '/data-strategies/': { registry: orbitRegistry.registrations.strategies },
-  };
-
-  for (const [folder, { registry }] of Object.entries(folderConfig) as [
-    Folder,
-    { registry: any },
-  ][]) {
-    const matches = Object.entries(modules).filter(([key]) =>
-      key.includes(folder),
+function injectDataBuckets(modules: Record<string, unknown>) {
+  const registry = orbitRegistry.registrations.buckets;
+  const matches = Object.entries(modules);
+
+  if (matches.length > 1) {
+    throw new Error(
+      `Expected only one file under /data-buckets/, found ${matches.length}: ` +
+        matches.map(([key]) => key).join(', '),
     );
+  }
 
-    if (folder === '/data-buckets/' && matches.length > 1) {
-      throw new Error(
-        `Expected only one file under /data-buckets/, found ${matches.length}: ` +
-          matches.map(([key]) => key).join(', '),
-      );
-    }
+  for (const [, module] of matches) {
+    registry['main'] = (
+      module as FactoryForFolderType['/data-buckets/']
+    ).default?.create?.();
+  }
+}
+
+function injectDataModels(modules: Record<string, unknown>) {
+  const folder = '/data-models/';
+  const registry = orbitRegistry.registrations.models;
+
+  for (const [key, module] of Object.entries(modules)) {
+    let [, name] = key.split(folder);
+    name = getName(name as string);
+
+    registry[name] =
+      (module as FactoryForFolderType['/data-models/']).default ??
+      (module as ModelFactory);
+  }
+}
+
+function injectDataSources(modules: Record<string, unknown>) {
+  const folder = '/data-sources/';
+  const registry = orbitRegistry.registrations.sources;
+
+  for (const [key, module] of Object.entries(modules)) {
+    let [, name] = key.split(folder);
+    name = getName(name as string);
+
+    registry[name] = (module as FactoryForFolderType['/data-sources/']).default // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      ?.create?.({} as any);
+  }
+}
 
-    for (const [key, module] of matches) {
-      if (folder === '/data-buckets/') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        registry['main'] = (
-          module as FactoryForFolderType['/data-buckets/']
-        ).default?.create?.();
-        continue;
-      }
-
-      let [, name] = key.split(folder);
-      name = getName(name as string);
-
-      if (folder === '/data-models/') {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        registry[name] =
-          (module as FactoryForFolderType[typeof folder]).default ??
-          (module as ModelFactory);
-      } else {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        registry[name] = (module as FactoryForFolderType[typeof folder]).default // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-          ?.create?.({} as any);
-      }
+function injectDataStrategies(modules: Record<string, unknown>) {
+  const folder = '/data-strategies/';
+  const registry = orbitRegistry.registrations.strategies;
+
+  for (const [key, module] of Object.entries(modules)) {
+    let [, name] = key.split(folder);
+    name = getName(name as string);
+
+    registry[name] = (
+      module as FactoryForFolderType['/data-strategies/']
+    ).default?.create?.();
+  }
+}
+
+function injectModules(modules: Record<string, unknown>) {
+  const bucketModules: Record<string, unknown> = {};
+  const modelModules: Record<string, unknown> = {};
+  const sourceModules: Record<string, unknown> = {};
+  const strategyModules: Record<string, unknown> = {};
+
+  for (const [key, module] of Object.entries(modules)) {
+    if (key.includes('/data-buckets/')) {
+      bucketModules[key] = module;
+    } else if (key.includes('/data-models/')) {
+      modelModules[key] = module;
+    } else if (key.includes('/data-sources/')) {
+      sourceModules[key] = module;
+    } else if (key.includes('/data-strategies/')) {
+      strategyModules[key] = module;
     }
   }
 
-  // Register the store source after processing all modules
-  orbitRegistry.registrations.sources['store'] = DataSourceStore.create(
-    {} as MemorySourceSettings,
-  );
+  injectDataBuckets(bucketModules);
+  injectDataModels(modelModules);
+  injectServices();
+  injectDataSources(sourceModules);
+  injectDataStrategies(strategyModules);
+}
+
+function injectServices() {
+  const keyMap = DataKeyMap.create();
+  const schema = DataSchema.create();
+  orbitRegistry.services.keyMap = keyMap;
+  orbitRegistry.services.schema = schema;
+  orbitRegistry.services.normalizer = DataNormalizer.create({
+    keyMap,
+    schema,
+  });
+  orbitRegistry.services.validatorFor = DataValidator.create({
+    validators: {},
+  });
 }
 
 export function setupOrbit(
-  application: Owner,
   modules: Record<string, unknown>,
   config?: { schemaVersion?: number },
 ) {
-  orbitRegistry.application = application;
   orbitRegistry.schemaVersion = config?.schemaVersion;
   injectModules(modules);
+  // Register the store source after processing all modules
+  orbitRegistry.registrations.sources['store'] = DataSourceStore.create(
+    {} as MemorySourceSettings,
+  );
 }

src/-private/factories/schema-factory.ts renamed to src/-private/services/data-schema.ts

@@ -1,14 +1,9 @@
-import type Owner from '@ember/owner';
-import Service, { service } from '@ember/service';
+import { Model } from '../../index.ts';
 import {
   type RecordFieldsOrModel,
   type RecordIdentityOrModel,
-} from '../-private/utils/model-aware-types.ts';
-import {
-  normalizeModelFields,
-  type ModelFields,
-} from '../-private/utils/model-fields.ts';
-import { Model } from '../index.ts';
+} from './model-aware-types.ts';
+import { normalizeModelFields, type ModelFields } from './model-fields.ts';
 import {
   RecordKeyMap,
   RecordSchema,
@@ -33,23 +28,14 @@ export function isStandardRecord(
   );
 }
 
-export default class ModelAwareNormalizer
-  extends Service
+export class ModelAwareNormalizer
   implements
     RecordNormalizer<string, RecordIdentityOrModel, RecordFieldsOrModel>
 {
-  @service declare dataKeyMap: RecordKeyMap;
-  @service declare dataSchema: RecordSchema;
-
   protected _normalizer: StandardRecordNormalizer;
 
-  constructor(owner: Owner) {
-    super(owner);
-
-    this._normalizer = new StandardRecordNormalizer({
-      keyMap: this.dataKeyMap,
-      schema: this.dataSchema,
-    });
+  constructor(settings: ModelRecordNormalizerSettings) {
+    this._normalizer = new StandardRecordNormalizer(settings);
   }
 
   get keyMap(): RecordKeyMap | undefined {

src/-private/factories/validator-factory.ts renamed to src/-private/services/data-validator.ts

@@ -1,11 +1,25 @@
-import type Owner from '@ember/owner';
 import type ModelFactory from '../model-factory.ts';
 import type { Strategy } from '@orbit/coordinator';
 import type { Bucket } from '@orbit/core';
 import type { Source } from '@orbit/data';
+import type {
+  RecordIdentity,
+  RecordKeyMap,
+  RecordNormalizer,
+  RecordSchema,
+  StandardRecordValidator,
+  UninitializedRecord,
+} from '@orbit/records';
+import type { StandardValidator, ValidatorForFn } from '@orbit/validators';
+
+type ServicesMap = {
+  keyMap: RecordKeyMap;
+  normalizer: RecordNormalizer<string, RecordIdentity, UninitializedRecord>;
+  schema: RecordSchema;
+  validatorFor: ValidatorForFn<StandardValidator | StandardRecordValidator>;
+};
 
 class OrbitRegistry {
-  application: Owner | null = null;
   registrations: {
     buckets: Record<'main', Bucket>;
     models: Record<string, ModelFactory>;
@@ -17,6 +31,7 @@ class OrbitRegistry {
     sources: {},
     strategies: {},
   };
+  services: ServicesMap = {} as ServicesMap;
   schemaVersion?: number;
 }
 

src/-private/system/ember-orbit-setup.ts

@@ -1,32 +1,12 @@
-import type ApplicationInstance from '@ember/application/instance';
 import { orbitRegistry } from './orbit-registry.ts';
-import type {
-  RecordIdentity,
-  RecordKeyMap,
-  RecordNormalizer,
-  RecordSchema,
-  RecordSourceSettings,
-  StandardRecordValidator,
-  UninitializedRecord,
-} from '@orbit/records';
-import type { StandardValidator, ValidatorForFn } from '@orbit/validators';
+import type { RecordSourceSettings } from '@orbit/records';
 
 export function applyStandardSourceInjections(
   injections: RecordSourceSettings,
 ): void {
-  const app = orbitRegistry.application as ApplicationInstance;
-
-  injections.schema = app.lookup('service:data-schema') as RecordSchema;
-
   injections.bucket = orbitRegistry.registrations.buckets['main'];
-
-  injections.keyMap = app.lookup('service:data-key-map') as RecordKeyMap;
-
-  injections.normalizer = app.lookup(
-    'service:data-normalizer',
-  ) as RecordNormalizer<string, RecordIdentity, UninitializedRecord>;
-
-  injections.validatorFor = app.lookup(
-    'service:data-validator',
-  ) as ValidatorForFn<StandardValidator | StandardRecordValidator>;
+  injections.keyMap = orbitRegistry.services.keyMap;
+  injections.normalizer = orbitRegistry.services.normalizer;
+  injections.schema = orbitRegistry.services.schema;
+  injections.validatorFor = orbitRegistry.services.validatorFor;
 }

src/services/data-normalizer.ts renamed to src/-private/utils/model-aware-normalizer.ts

@@ -1,6 +1,4 @@
 export { default as CoordinatorFactory } from './-private/factories/coordinator-factory.ts';
-export { default as KeyMapFactory } from './-private/factories/key-map-factory.ts';
-export { default as SchemaFactory } from './-private/factories/schema-factory.ts';
 export { default as MemorySourceFactory } from './-private/factories/memory-source-factory.ts';
 export { default as StoreFactory } from './-private/factories/memory-source-factory.ts';
 export { default as attr } from './-private/fields/attr.ts';
@@ -14,4 +12,5 @@ export { default as Store, type StoreSettings } from './-private/store.ts';
 export { default as LiveQuery } from './-private/live-query.ts';
 // Provide `belongsTo` as an alias to `hasOne`
 export { default as belongsTo } from './-private/fields/has-one.ts';
+export { orbitRegistry } from './-private/utils/orbit-registry.ts';
 export { setupOrbit } from './-private/system/ember-orbit-setup.ts';