Setting up flow for resolvers.

Repo structure classes should be responsible for pulling versioned files.
Ex. /forge/1.14/ -> get the latest file (or only allow one file).
The resolver then gets that file to work with in order to resolve the forge
module, pull its libs, and attach them as submodules.

src/index.ts

@@ -2,7 +2,7 @@
 import { writeFile } from 'fs-extra'
 import { resolve as resolvePath } from 'path'
 import yargs from 'yargs'
-import { DistributionStructure } from './model/struct/distribution.struct'
+import { DistributionStructure } from './model/struct/model/distribution.struct'
 
 function rootOption(yargs: yargs.Argv) {
     return yargs.option('root', {

src/model/resolver/asset.ts

@@ -0,0 +1,9 @@
+export interface Asset {
+
+    url: string
+    path: string
+    size: number
+    hashType: string
+    hash: string
+
+}

src/model/struct/BaseFileStructure.ts

@@ -1,17 +1,15 @@
 import { mkdirs } from 'fs-extra'
 import { join, resolve } from 'path'
-import { ModelStructure } from './model.struct'
+import { FileStructure } from './FileStructure'
 
-export abstract class BaseModelStructure<T> implements ModelStructure<T[]> {
+export abstract class BaseFileStructure implements FileStructure {
 
-    protected resolvedModels: T[] | undefined
     protected containerDirectory: string
 
     constructor(
         protected absoluteRoot: string,
         protected relativeRoot: string,
-        protected structRoot: string,
+        protected structRoot: string
-        protected baseUrl: string
     ) {
         this.relativeRoot = join(relativeRoot, structRoot)
         this.containerDirectory = resolve(absoluteRoot, structRoot)
@@ -21,6 +19,4 @@ export abstract class BaseModelStructure<T> implements ModelStructure<T[]> {
         mkdirs(this.containerDirectory)
     }
 
-    public abstract async getSpecModel(): Promise<T[]>
-
 }

src/model/struct/FileStructure.ts

@@ -0,0 +1,5 @@
+export interface FileStructure {
+
+    init(): void
+
+}

src/model/struct/model.struct.ts

@@ -1,7 +0,0 @@
-export interface ModelStructure<T> {
-
-    init(): void
-
-    getSpecModel(): Promise<T>
-
-}

src/model/struct/model/ModelStructure.ts

@@ -0,0 +1,7 @@
+import { FileStructure } from '../FileStructure'
+
+export interface ModelStructure<T> extends FileStructure {
+
+    getSpecModel(): Promise<T>
+
+}

src/model/struct/model/basemodel.struct.ts

@@ -0,0 +1,19 @@
+import { BaseFileStructure } from '../BaseFileStructure'
+import { ModelStructure } from './ModelStructure'
+
+export abstract class BaseModelStructure<T> extends BaseFileStructure implements ModelStructure<T[]> {
+
+    protected resolvedModels: T[] | undefined
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string,
+        structRoot: string,
+        protected baseUrl: string
+    ) {
+        super(absoluteRoot, relativeRoot, structRoot)
+    }
+
+    public abstract async getSpecModel(): Promise<T[]>
+
+}

src/model/struct/model/distribution.struct.ts

@@ -1,6 +1,6 @@
 import { mkdirs } from 'fs-extra'
-import { Distribution } from '../spec/distribution'
+import { Distribution } from '../../spec/distribution'
-import { ModelStructure } from './model.struct'
+import { ModelStructure } from './ModelStructure'
 import { ServerStructure } from './server.struct'
 
 export class DistributionStructure implements ModelStructure<Distribution> {

src/model/struct/model/module/file.struct.ts

@@ -1,10 +1,10 @@
 import { Stats } from 'fs'
 import { join } from 'path'
 import { resolve } from 'url'
-import { Type } from '../../spec/type'
+import { Type } from '../../../spec/type'
 import { ModuleStructure } from './module.struct'
 
-export class FileStructure extends ModuleStructure {
+export class MiscFileStructure extends ModuleStructure {
 
     constructor(
         absoluteRoot: string,

src/model/struct/model/module/forgemod.struct.ts

@@ -2,10 +2,10 @@ import AdmZip from 'adm-zip'
 import { Stats } from 'fs-extra'
 import { join } from 'path'
 import { resolve } from 'url'
-import { capitalize } from '../../../util/stringutils'
+import { capitalize } from '../../../../util/stringutils'
-import { McModInfo } from '../../forge/mcmodinfo'
+import { McModInfo } from '../../../forge/mcmodinfo'
-import { McModInfoList } from '../../forge/mcmodinfolist'
+import { McModInfoList } from '../../../forge/mcmodinfolist'
-import { Type } from '../../spec/type'
+import { Type } from '../../../spec/type'
 import { ModuleStructure } from './module.struct'
 
 export class ForgeModStructure extends ModuleStructure {

src/model/struct/model/module/litemod.struct.ts

@@ -2,9 +2,9 @@ import AdmZip from 'adm-zip'
 import { Stats } from 'fs-extra'
 import { join } from 'path'
 import { resolve } from 'url'
-import { capitalize } from '../../../util/stringutils'
+import { capitalize } from '../../../../util/stringutils'
-import { LiteMod } from '../../liteloader/litemod'
+import { LiteMod } from '../../../liteloader/litemod'
-import { Type } from '../../spec/type'
+import { Type } from '../../../spec/type'
 import { ModuleStructure } from './module.struct'
 
 export class LiteModStructure extends ModuleStructure {

src/model/struct/model/module/module.struct.ts

@@ -1,8 +1,8 @@
 import { createHash } from 'crypto'
 import { lstat, pathExists, readdir, readFile, Stats } from 'fs-extra'
 import { resolve } from 'path'
-import { Module } from '../../spec/module'
+import { Module } from '../../../spec/module'
-import { Type, TypeMetadata } from '../../spec/type'
+import { Type, TypeMetadata } from '../../../spec/type'
 import { BaseModelStructure } from '../basemodel.struct'
 
 export abstract class ModuleStructure extends BaseModelStructure<Module> {

src/model/struct/model/server.struct.ts

@@ -1,9 +1,9 @@
 import { lstat, readdir } from 'fs-extra'
 import { join, resolve as resolvePath } from 'path'
 import { resolve as resolveUrl } from 'url'
-import { Server } from '../spec/server'
+import { Server } from '../../spec/server'
 import { BaseModelStructure } from './basemodel.struct'
-import { FileStructure } from './module/file.struct'
+import { MiscFileStructure } from './module/file.struct'
 import { ForgeModStructure } from './module/forgemod.struct'
 import { LiteModStructure } from './module/litemod.struct'
 
@@ -63,7 +63,7 @@ export class ServerStructure extends BaseModelStructure<Server> {
                 const liteModStruct = new LiteModStructure(absoluteServerRoot, relativeServerRoot, this.baseUrl)
                 const liteModModules = await liteModStruct.getSpecModel()
 
-                const fileStruct = new FileStructure(absoluteServerRoot, relativeServerRoot, this.baseUrl)
+                const fileStruct = new MiscFileStructure(absoluteServerRoot, relativeServerRoot, this.baseUrl)
                 const fileModules = await fileStruct.getSpecModel()
 
                 const modules = [

src/model/struct/repo/forgerepo.struct.ts

@@ -0,0 +1,12 @@
+import { BaseFileStructure } from '../BaseFileStructure'
+
+export class ForgeRepoStructure extends BaseFileStructure {
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string
+    ) {
+        super(absoluteRoot, relativeRoot, 'forge')
+    }
+
+}

src/model/struct/repo/librepo.struct.ts

@@ -0,0 +1,12 @@
+import { BaseFileStructure } from '../BaseFileStructure'
+
+export class LibRepoStructure extends BaseFileStructure {
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string
+    ) {
+        super(absoluteRoot, relativeRoot, 'lib')
+    }
+
+}

src/model/struct/repo/liteloaderrepo.struct.ts

@@ -0,0 +1,12 @@
+import { BaseFileStructure } from '../BaseFileStructure'
+
+export class LiteLoaderRepoStructure extends BaseFileStructure {
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string
+    ) {
+        super(absoluteRoot, relativeRoot, 'liteloader')
+    }
+
+}

src/model/struct/repo/repo.struct.ts

@@ -0,0 +1,41 @@
+import { BaseFileStructure } from '../BaseFileStructure'
+import { ForgeRepoStructure } from './forgerepo.struct'
+import { LibRepoStructure } from './librepo.struct'
+import { LiteLoaderRepoStructure } from './liteloaderrepo.struct'
+
+export class RepoStructure extends BaseFileStructure {
+
+    private forgeRepoStruct: ForgeRepoStructure
+    private liteloaderRepoStruct: LiteLoaderRepoStructure
+    private libRepoStruct: LibRepoStructure
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string
+    ) {
+        super(absoluteRoot, relativeRoot, 'repo')
+        this.forgeRepoStruct = new ForgeRepoStructure(this.containerDirectory, this.relativeRoot)
+        this.liteloaderRepoStruct = new LiteLoaderRepoStructure(this.containerDirectory, this.relativeRoot)
+        this.libRepoStruct = new LibRepoStructure(this.containerDirectory, this.relativeRoot)
+    }
+
+    public async init() {
+        super.init()
+        await this.forgeRepoStruct.init()
+        await this.liteloaderRepoStruct.init()
+        await this.libRepoStruct.init()
+    }
+
+    public getForgeRepoStruct() {
+        return this.forgeRepoStruct
+    }
+
+    public getLiteLoaderRepoStruct() {
+        return this.liteloaderRepoStruct
+    }
+
+    public getLibRepoStruct() {
+        return this.libRepoStruct
+    }
+
+}

src/resolver/baseresolver.ts

@@ -0,0 +1,13 @@
+import { Module } from '../model/spec/module'
+import { Resolver } from './resolver'
+
+export abstract class BaseResolver implements Resolver {
+
+    constructor(
+        protected absoluteRoot: string,
+        protected relativeRoot: string
+    ) {}
+
+    public abstract getModule(): Promise<Module>
+
+}

src/resolver/forge/adapter/forge18.resolver.ts

@@ -0,0 +1,10 @@
+import { Module } from '../../../model/spec/module'
+import { ForgeResolver } from '../forge.resolver'
+
+export class Forge18Adapter extends ForgeResolver {
+
+    public async getModule(): Promise<Module> {
+        return null as unknown as Module
+    }
+
+}

src/resolver/forge/forge.resolver.ts

@@ -0,0 +1,33 @@
+import { Module } from '../../model/spec/module'
+import { RepoStructure } from '../../model/struct/repo/repo.struct'
+import { BaseResolver } from '../baseresolver'
+import { Forge18Adapter } from './adapter/forge18.resolver'
+
+export abstract class ForgeResolver extends BaseResolver {
+
+    public static getResolver(version: string) {
+        return ForgeResolver.ADAPTER_LIST[version]
+    }
+
+    // tslint:disable: object-literal-key-quotes
+    private static readonly ADAPTER_LIST: {[version: string]: any} = {
+        '1.8': Forge18Adapter,
+        '1.9': Forge18Adapter,
+        '1.10': Forge18Adapter,
+        '1.11': Forge18Adapter,
+        '1.12': Forge18Adapter
+    }
+
+    protected repoStructure: RepoStructure
+
+    constructor(
+        absoluteRoot: string,
+        relativeRoot: string
+    ) {
+        super(absoluteRoot, relativeRoot)
+        this.repoStructure = new RepoStructure(absoluteRoot, relativeRoot)
+    }
+
+    public abstract getModule(): Promise<Module>
+
+}

src/resolver/resolver.ts

@@ -0,0 +1,7 @@
+import { Module } from '../model/spec/module'
+
+export interface Resolver {
+
+    getModule(): Promise<Module>
+
+}