00:05
All right. So before we leave our basics module here,
00:07
let's quickly talk about what we can and cannot share between
00:10
our Adonis and client-side application view,
00:13
in this case, with InertiaJS.
00:15
As we previously discussed,
00:16
inside of our application,
00:18
we have access to these reference directives.
00:20
These allow our InertiaView application, in this case,
00:24
to be able to understand types from AdonisJS using module augmentation.
00:28
Module augmentation being where you dynamically add things using that.
00:32
Declare module, the namespace, and then add the types in.
00:35
What we cannot make use of these reference directives for is
00:38
dynamically inferred types or really anything added
00:41
in whenever our application is run through its boot cycle.
00:44
Because at the point that we're in our InertiaView application here,
00:48
our Adonis application is completely out of the picture.
00:51
Sure, it's used whenever we do server-side rendering,
00:54
but we need to treat it the same as we are
00:56
accessing it inside of the browser because
00:58
the actual view application is still running on the client,
01:01
even though we're rendering it initially on the server here using SSR.
01:05
Meaning that any code that we want to use that relies on
01:08
our booted AdonisJS application,
01:10
which is the event system, HTTP contacts, dependency injection,
01:13
really anything like that, the mailer,
01:15
that all requires the AdonisJS application to be
01:17
booted in order for it to work properly.
01:19
In terms of that, none of that stuff can be
01:21
shared with our InertiaView application here.
01:24
If however, say we go up to our app and we create a service,
01:27
new file, services, and we create something like a utility service,
01:31
.ts, export default class utility service,
01:36
and we add, I'm just going to make a static,
01:38
some method here where you can return working, give that a save.
01:43
If we had something like this that we
01:45
wanted to share with our Inertia application,
01:46
that would be perfectly fine.
01:48
So we can jump into, say,
01:49
our login page and import our utility service
01:53
from hash services utility service,
01:56
and then we can make direct use of this inside of
01:58
our template or our script as needed.
02:00
So if we just do hyphen utility service.some method,
02:04
and we call that directly inside of our template,
02:06
jump back into our browser, give that a refresh.
02:08
You can see that we see login hyphen working,
02:11
working coming from that some method from
02:13
our app services utility service class.
02:15
So really the main thing to take away here is,
02:18
if your AdonisJS application needs to
02:19
be booted in order for something to work,
02:21
no, you cannot use it inside of your Inertia view application.
02:24
At that point, you need to treat them as
02:25
two separate applications decoupled from one another,
02:28
because the app on your client side is
02:30
still running the browser at the end of the day,
02:32
and your AdonisJS application is still run on the server.
02:35
Inertia is just brokering the transfer flow between those two,
02:39
but it cannot share running instances between the two.
02:42
I'll note this, even though we'll get to
02:44
it later on whenever we actually start talking about it,
02:46
types for models cannot be shared directly either,
02:49
because if you try to,
02:51
the inference will just come through as model object,
02:53
and it won't actually contain any of
02:55
your models columns due to the way that the models are written.
02:58
Because of this, in this series,
02:59
we'll be using DTOs to describe our models.
03:01
Of course, you could always do casting instead of DTOs,
03:04
if you prefer to do that, that's where you do the variable,
03:06
and then as, and then describe the type yourself.
Join The Discussion! (0 Comments)
Please sign in or sign up for free to join in on the dicussion.
Be the first to Comment!