initial

Author: 3y3k0

.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+/build

package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@modelsjs/resolver",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@modelsjs/model": "^0.0.1",
+    "@modelsjs/tsconfig": "^0.0.1",
+    "@modelsjs/types": "^0.0.1"
+  }
+}

src/config.ts

@@ -0,0 +1,27 @@
+import { IStrategy } from './types';
+
+const prop = <T>(key: string, defaults?: T) => ({
+        get(): T {
+            if (defaults) {
+                return defaults;
+            }
+
+            throw new Error(`Key '${key}' is not configured.`);
+        },
+
+        set(value: T) {
+            Object.defineProperty(this, key, {
+                set() {
+                    throw new Error(`Key '${key}' is already configured.`);
+                },
+
+                get() {
+                    return value;
+                }
+            });
+        }
+    });
+
+export const config = Object.create(null, {
+    defaultStrategy: prop<Nullable<IStrategy>>('defaultStrategy', null)
+});

src/index.ts

@@ -0,0 +1,4 @@
+export type { IStrategy, TResolver } from './types';
+export { config } from './config';
+export { resolve } from './resolve';
+export { resolvable } from './resolvable';

src/resolvable.ts

@@ -0,0 +1,40 @@
+import type { Model } from '@modelsjs/model';
+import type { IStrategy } from './types';
+import { config } from './config';
+import { ResolveStrategy } from './symbols';
+
+type TStrategies = Record<symbol, IStrategy>;
+
+export interface IResolvable<M extends Model> {
+    [prop: string]: any;
+
+    [ResolveStrategy]: TStrategies;
+}
+
+export function resolvable<M extends Model>(strategy: IStrategy): ClassDecorator
+export function resolvable<M extends Model>(target: ClassDescriptor): void
+export function resolvable<M extends Model>(target: any): any {
+    const strategy: IStrategy = isClassDescriptor(target) ? config.defaultStrategy : target;
+
+    function decorator({elements}: ClassDescriptor) {
+        elements.push({
+            kind: 'field',
+            placement: 'own',
+            key: strategy.kind,
+            descriptor: {},
+            initializer: function() {
+                return strategy;
+            }
+        } as FieldDescriptor);
+    }
+
+    return isClassDescriptor(target) ? decorator(target) : decorator;
+}
+
+resolvable.get = <M extends Model>(resolvable: Partial<IResolvable<M>>): TStrategies | null => {
+    return resolvable[ResolveStrategy] || null;
+}
+
+function isClassDescriptor(target: any): target is ClassDescriptor {
+    return target?.kind === 'class' && Array.isArray(target.elements);
+}

src/resolve.ts

@@ -0,0 +1,34 @@
+import type { Model } from '@modelsjs/model';
+import type { TResolver, ISyncResolver } from './types';
+
+export async function resolve(models: Model[], resolvers: TResolver[]) {
+    let [ resolved, rest ] = [ [] as Model[], models.slice() ];
+    for (const resolver of resolvers) {
+        if (!rest.length) {
+            return;
+        }
+
+        if (isSync(resolver)) {
+            [ resolved, rest ] = resolver.sync(models);
+        } else {
+            [ resolved, rest ] = await resolver.async(models);
+        }
+    }
+}
+
+resolve.sync = (models: Model[], resolvers: TResolver[]) => {
+    let [ resolved, rest ] = [ [] as Model[], models.slice() ];
+    for (const resolver of resolvers) {
+        if (!rest.length) {
+            return;
+        }
+
+        if (isSync(resolver)) {
+            [ resolved, rest ] = resolver.sync(models);
+        }
+    }
+}
+
+function isSync(resolver: TResolver): resolver is ISyncResolver {
+    return 'sync' in resolver;
+}

src/symbols.ts

@@ -0,0 +1 @@
+export const ResolveStrategy = Symbol('ResolveStrategy');

src/types.ts

@@ -0,0 +1,19 @@
+import type { Model } from '@modelsjs/model';
+
+export type TDecorated<T> = T & {
+    [prop: symbol]: IStrategy
+};
+
+export interface ISyncResolver {
+    sync(models: Model[]): [ Model[], Model[] ];
+}
+
+export interface IAsyncResolver {
+    async(models: Model[]): Promise<[ Model[], Model[] ]>;
+}
+
+export type TResolver = OneOf<ISyncResolver & IAsyncResolver>;
+
+export interface IStrategy {
+    kind: symbol;
+}

tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@modelsjs/tsconfig/tsconfig",
+  "compilerOptions": {
+    "outDir": "build"
+  },
+  "include": [
+    "src",
+    "node_modules/@modelsjs/types",
+    "../../node_modules/@modelsjs/types"
+  ]
+}