how to create new packages for adonis 5

[dev-talha-anwar]

how can i create new packages in v5. i have seen articles like
https://steemit.com/utopian-io/@creatrixity/building-your-own-adonisjs-package
this but it is for v4 and it does not includes how to use controllers,routes,middleware etc.
is there a complete guide on create packages ? Thanks

[McSneaky]

Haven't seen complete guide yet. Here's small one I made: https://mcsneaky.ap3k.pro/posts/adonis-v5-provider/
But it's not going over controllers, routes, middlewares etc

You can take a look at some relatively simple Adonis module, like Redis or Bouncer and look how they are built

[skrenek]

Thanks for this. I've been looking into creating my own Adonis packages for re-use and this gave me a big head-start. 👏

[bingtsingw]

It's really helpful, thank you very much

[vookio]

Hello,

I also would like to create new packages that can be installed by the customers on demand like a marketplace approach. These packages need its own controllers, routes, validators, middleware, migrations, ... and has to be external, shareable, plug & play. So they are not pre-registered in the application (.adonisrc.json, kernel.ts, ...)

@McSneaky 's post is helpful and I created providers earlier and used them in the controllers but none of them has its own controllers, routes, validators, middleware, migrations, ...

It seems this will be covered with package development in the roadmap

Could you please share leading information at least about how can this be done? An existing repository to follow is also helpful. Thanks.

[dqgiang]

@McSneaky
Thanks for the guide. It's very helpful to get started.
Have you developed separate packages including Models, Validators, etc.? If so, I'd very much appreciate if you could share your experience.

I've managed to have custom routes, controllers and models but they (especially the models) must be created in somewhat inconvenient way.

• The controller bindings are registered manually in provider with explicit constructor call. Actually not too bad. Most of the code is identical to normal controller written in the main app, except passing container in constructor to resolve dependencies on demand.
• The model declarations are wrapped inside a function because I need container object to resolve bindings to Adonis/Lucid/Orm. It works but I haven't figured out how to make it aware of the proper type of the model (for intellisense or type check). Right now the model is just of any type.

Sample code below. I just feel that it's not the most accurate way to do it.
Demo repo here.

Besides, I don't understand why ioc resolve doesn't work with external provider the way it works with internal provider.
The error is Module not found so I suppose it understands the import '@ioc:Adonis/...' as a standard module and doesn't even bother with ioc. Seems like a critical knowledge I'm missing.

// controller
import { IocContract } from "@ioc:Adonis/Core/Application";
import { HttpContextContract } from "@ioc:Adonis/Core/HttpContext";
import { createUserModel } from "../Models/User";

export default class MyController {
  public constructor(private _container: IocContract) { // 👈 Perhaps will also pass Validator object like this
  }

  public async index() {
    const User = await createUserModel(this._container);
    return await User.all();
  }

  public async show(ctx: HttpContextContract) {
    const id = ctx.request.param("id");
    const User = await createUserModel(this._container);
    return await User.findOrFail(id);
  }
}

// model
import { DateTime } from "luxon";
import { IocContract } from "@ioc:Adonis/Core/Application";
import { column } from "@adonisjs/lucid/build/src/Orm/Decorators";

export async function createUserModel(container: IocContract): Promise<any> { // 👈 Don't know yet how to have proper return type of User
  const { BaseModel } = container.use("Adonis/Lucid/Orm");

  class User extends BaseModel {
    public static table = "users";

    @column({ isPrimary: true })
    public id: number;

    @column.dateTime({ autoCreate: true })
    public createdAt: DateTime;

    @column.dateTime({ autoCreate: true, autoUpdate: true })
    public updatedAt: DateTime;
  }

  return User;
}

[dqgiang]

Update: I think I (kind of) figure out how to make it work properly.

Target

1. Develop a separate package from the main app that can be distributed independently.
2. Keep the nice DevEx while working in both the main app and the package: type check, intellisense, etc.
3. Package can declare custom routes, controllers, models, etc. Some are booted automatically into the main app without developer doing anything.
4. Main app can refer to stuff from the package, either through IoC resolve or standard module import (also with alias)

Demo code: https://github.com/dqgiang/demo-adonis-package

The main issue for me was to make resolve of import @ioc in the package work correctly.
If I write import Something from '@ioc:...' in the package, it wouldn't work when I run the app, throwing "Cannot find module '@ioc:...".
Then I checked the compiled code of the package and see that the ioc import statement was incorrect.

// expectation
const Orm_1 = global[Symbol.for('ioc.use')]("Adonis/Lucid/Orm");

// actual result
const Orm_1 = require("@ioc:Adonis/Lucid/Orm");

A bit digging (through various docs pages and official packages) showed me that we needed to transform this IoC import statement when compile, cannot just tsc all the way.
I resorted to make a custom build script, take ideas from the adonis build command to leverage the existing Compiler.
More understanding of the compiler setup might be needed, but that solved it.
Now I can import @ioc like I normally would in regular app, which enables type check and intellisense, etc. and helps keep the package code almost identical to writing module provider inside the main app.

[kevin1193]

How did you manage to resolve the tsc build? when I include @adonisk

[shymelon]

That works nice, thank you! But how can I preserve intellisense for models?

[afidosstar]

Thanks @dqgiang for your help. It really helped to understand the problem I had with the compilation. The solution is precisely the @adonisjs/ioc-transformer module.
After some more research to find an easier way to solve the problem
create <project_dir>/transformer.js

const { iocTransformer } = require("@adonisjs/ioc-transformer");

module.exports = function () {
  return iocTransformer(require("typescript/lib/typescript"), { aliases: {} });
};

in your <project_dir>/tsconfig.json

{
     ....
    "compilerOptions": {
       ....
       "plugins": [
           {
              "transform": "./transformer.js",
              "after": true
           }
       ]
   }
}

Currently TypeScript doesn't support custom transformers in the tsconfig.json, but supports it programmatically.

And there is no way to compile your files using custom transformers using tsc command.
To solve this, use ttypescript

npm i ttypescript -D

Instead of typescript use ttypescript for compilation

ttsc