►
From YouTube: hyper63 hacking 2/8
Description
Part 1 of adding the bulk api endpoint for the data port
https://github.com/hyper63/hyper63
A
B
B
B
B
You
know
those
types
of
things
and
then
you
have
your
core
and
and
your
core
is
just
really
kind
of
the
the
the
keeper
of
the
business
rules
right.
So
so,
basically,
in
nbc
days,
you
could
think
of
this
as
more
as
kind
of
the
controller
in
the
model
kind
of
combined,
and
then
you
have
these
ports
and
a
port.
Basically,
all
it's
responsible
to
do
is
make
sure
that
an
adapter
implements
a
specific
specification.
B
So
if
the
data
features
is
the
ability
to
create,
read,
update
and
delete
right,
then
the
adapter,
regardless
of
what
the
adapter
driver,
is,
needs
to
implement
those
with
specific
function
patterns,
and
you
know,
if
I
throw
an
adapter
on
here,
you
know
mongodb
and
it
doesn't
implement
those
things.
Then
I
need
when,
when
hyper
fires
up,
I
need
hyper
to
yell
at
me
and
say:
you're
trying
to
use
mongodb
and
that
adapter
is
not
is
not
compatible
with
the
data
port.
B
So,
with
this
issue,
we're
gonna
add
a
new
endpoint
called
bulk,
and
this
bulk
endpoint
will
allow
us
to
send
multiple
json
documents
through
the
xpress
app
through
core
and
then
into
an
adapter.
So
we
gotta
kind
of
touch
the
app
core,
the
data
port,
because
it's
a
new
specification
and
then
each
adapter
that's
defined,
and
you
know
again
from
my
standpoint:
you're
gonna
tackle
this
any
kind
of
way,
but
I'm
gonna
kind
of
write.
The
documentation
first,
at
least
enough
to
to
you,
know
suss
out
any
kind
of
issues
right.
B
B
Yeah
yeah,
so
let's
say
you
wanted
to
to
migrate
from
one
one:
implementation:
data
store
to
another
implementation
data
store.
You
could
use
this
bulk
feature,
but
but
basically
just
to
give
you
an
idea
how
it
would
look
is
like
post
data
name
and
then
bulk,
and
then
you
would
just
send
an
array
of
json.
B
Documents
and
again,
if,
if
I
were
building
a
migration,
I
would
probably
like
create
like
a
pagination
stream
right.
So
I'd
grab
like
a
chunk
of
a
thousand
documents
and
then
bulk
upload
those
thousand
and
then
grab
the
next
chunk
of
a
thousand
and
then
bulk
and
just
create
a
stream
between
the
processes
right
and
basically
the
the
bulk
api.
B
If,
if
the
data
doesn't
exist,
then
it's
going
to
create
a
new
one.
If
it
does
exist-
and
you
know-
has
a
valid
id,
then
it
will
merge
what's
in
there
with
what
you
send
and
then
the
other
option
that
I
kind
of
put
in
here
is
maybe,
if
you
send
underscore
delete
true
as
part
of
your
document,
it
could
actually
remove
it.
So
that
kind
of
gives
you
this
full
kind
of
bulk,
read,
update
and
remove
kind
of
flow.
B
B
C
C
C
C
B
C
A
C
B
C
B
A
B
C
C
C
B
C
C
C
B
I'm
not
trying
to
get
it
super
polished,
but
just
get
enough
down
so
that
when
I
step
away,
I
have
something
to
reference
and
then
hopefully
like
by
the
time.
I
finish
this
whole
feature.
I
can
come
back
here
and
you
know
really
put
some
some
good
context
together,
but
does
that
look
good
to
everybody?.
B
B
So
it's
laid
out
in
a
mono
repo.
So
if
I
do
a
list
and
then
there's
got
to
got
to
do
some
cleanup
but
the
most
important
one
is
this
packages
folder,
that's
where
all
the
kind
of
the
code
lives
and
then
the
other
one
is
this
images
folder
and
the
images
folder
actually
contains
different
builds
of
hyper.
So
if
I
go
into
the
images
folder
and
and
see.
B
B
The
other
thing
of
note
is
the
the
hyper
63
config
file.
If
we
looked
at
that
diagram
again,
this
config
file
is
like
the
code
version
of
that
diagram.
So
for
this
build
I'm
using
express
as
my
app
and
I'm
using
you
know,
memory
as
my
adapter
for
the
cache
port
using
pouch
db
as
my
adapter
for
the
data
port,
I'm
using
mini
search
as
the
adapter
for
my
search
port
and
then
my
middleware.
I've
got
a
jwt
file
for
my
middleware
that
just
creates
a
shared
secret
token
validator.
B
B
I
can
see
okay
and
then
in
app
express
it's
just
a
a
simple
express
app.
If
we
look
at
package.json,
it's
got
cores
express
helmet,
mine,
multer
and
there's
dependencies
and
using
tape
as
a
test
framework.
So
the
first
thing
so,
let's
see
if
all
of
our
tests
pass
that'll
be
a
good
check
and
they
do
and
if
we
look
at
index.js,
this
has
all
of
our
kind
of
endpoints,
but
there's
not
a
lot
of
code
behind
them.
It's
just
kind
of
describing
the
the
end
point.
C
B
C
C
B
C
B
B
So
I
can
destructure
it
by
using
the
curly
braces
and
just
grab
data,
and
I
want
to
get
params
because
that'll
have
the
name
of
the
db
and
then
I
want
to
get
body
which
will
be
the
array
of
documents
that
I
want
to
work
on
and
then
I've
got
the
response
object.
So
basically,
that's
just
a
shortcut
for
doing
request.data,
request.params
request.body
and
then
I'm
going
to
call
this
fork
function
and
we'll
talk
about
that
later.
B
But
but
basically
the
fork
function
will
run
everything
and
then
either
an
error
function
will
be
called
or
a
success
function
will
be
called
and
fork
just
handles
that
so
that
all
the
side
effects
are
pushed
at
the
point
of
the
endpoint,
but
basically
the
endpoint
doesn't
have
to
think
about
it.
It's
either
going
to
get
an
error
or
a
success.
C
B
The
first
argument
will
be
the
error
function
handler
and
the
second
would
be
the
success
function
handler
and
then
what
it's
going
to
do
is
just
if
it's
an
error,
it's
going
to
see
what
the
error
status
is,
if
it's
specified
and
then
set
that
so
in
case
I
want
to
say
this
is
a
401
you're
not
authorized
or
a
404.
What
you're
looking
for
is
not
found.
I
can
specify
that
in
my
error
object
that
I'll
pass
down
the
chain.
If
it
doesn't
have
a
status,
then
it's
just
going
to
say:
500.
B
B
C
B
So
what
we're
going
to
do
is
we're
going
to
run
this
through
like
a
test
server
and
we'll
actually
do
a
post
and
we'll
actually
mock
out
the
services
so
that
it
returns
a
result.
But
then
we
should
get
a
kind
of
just
testing
the
code
that
we
just
added,
we'll
verify
it
that
that
works.
So
let's
create
an
app
and
we
require.
C
C
B
And
I
try
not
to
make
these
tests
too
complicated,
so
I'm
not
really
worried
about
the
data
at
this
point
as
much
as
I'm
just
trying
to
test
the
code
that
I
just
wrote
right
just
to
make
sure
that
the
code
I
wrote
works
and
if
it
doesn't
work
it
yells
at
me,
so
we'll
get
a
response.
We'll
do
away
away
fetch
server.url.
B
C
C
C
B
C
B
B
Okay,
we
get
an
error,
cannot
read
property
fork
of
null
cool,
so
it
got
the
bulk
and
it
called
it
and
returned
null
and
it's
trying
to
return
fork.
So
we
could
do
a
couple
of
things
one
is:
is
we
could
return
an
object
with
a
method
fork
on
it
and
do
it
that
way
or
we
could
just
use
a
sink
object
either
way.
C
B
C
C
C
C
C
B
So
we've
got
the
endpoint
implemented,
we
created
kind
of
a
happy
test
and
if
we
go
to
our
actions,
hopefully
we
see
just
the
just
the
test:
app
express
github
action
running.
So
it's
running
that
test
and
it's
it's
actually
set
up,
which
is
pretty
cool.
You
create
a
pull
request
and
when
that
pull
request
is
approved,
it
will
actually
publish
that
to
npm,
so
it
will
publish
the
app
express
module
to
npm.
B
B
A
B
B
Go
to
the
core
or
well
actually
what
I'll
do
is
go
to
the
port,
because
I
think
this
is
really
cool
to
implement
the
port.
So
if
we
go
back
to
our
diagram,
we've
got
this
data
port.
The
data
port
is
the
cop
right.
It's
the
one,
keeping
the
schema
so
really
a
method
can't
exist
in
an
adapter
and
core
can't
obviously
call
a
method
unless
the
port
specifies
it.
B
C
D
Bulk
tom
correct
me,
if
I'm
wrong,
but
those
ports
they're
also
doing
some
sort
of
they're
also
doing
some
validation
on
the
inputs
and
outputs
so
that
anyone
that
wants
to
implement
an
adapter.
They
don't
have
to
do
all
that
boilerplate
sort
of
validation
on
inputs.
They
kind
of
get
all
that
out
of
the
box
with
the
with
the
core
sort
of
validation.
B
Yeah,
that's
one
of
the
coolest
things
about
this.
We're
using
a
library
called
zod,
and
it
actually
not
only
allows
you
to
specify
the
object
shape
but
it'll
actually
validate
the
function.
Call
at
runtime
and
it's
important
for
this
to
validate
at
run
time,
because
when
you're,
putting
an
adapter
that
adapter
may
be
written
by
some
third
party
right
and
when
you
run
your
instance
of
hyper
63,
you
want
those
validations
to
fire
at
run
time,
not
necessarily
at
compile
time
right.
B
So
this
is
the
schema
definition.
It's
really
simple,
you
have
this
z
object
and
then
it's
got
arguments
on
on
there
to
specify
certain
values
and
they
can
chain
together.
So
here
we've
got
this
create
fun
database
as
a
function
and
its
arguments
is
a
string
and
it
returns
a
promise
that
returns
an
object
that
looks
like
this
boolean,
etc.
B
B
C
B
B
I
think
right
now
it's
going
to
be
db
and
docs
right,
which
will
be
an
array
and
inside
that
array
will
be
an
object,
but
we
don't
necessarily
know
the
the
shape
of
those
objects,
so
it
has
an
any
just
like
typescript
and
the
nice
thing
about
zod.
Is
it
kind
of
mimics
the
type
system
of
typescript
and
it
can
actually
generate
typescript
types
from
it
as
well?
So
that's
pretty
cool
and
then.
B
B
B
That's
the
adapter
actually
being
passed
in
and
we
just
wrap
that
and
what
that'll
do
is
that'll
validate
all
of
the
arguments
and
the
returns
as
it's
running.
So
it's
acting
like
you
know
what
like
in
react
when
you
use
higher
order,
functions
to
wrap,
wrap
stuff,
that's
that's
what
it's
basically
doing,
yeah
and
let's
go
and
check
our
documentation
and
that's
why
we
write
the
documentation,
so
we
can
go
and
check
it.
B
B
C
B
D
A
B
B
I
just
can't
take
it
anymore,
cool
so
so
so
we've
got
this
error
and
that's
that's
how
I
want
to
get
this
library
is
like,
as
we
do
things,
we've
got
high
signal
when
things
are
broken,
and
so
here
we
we've
added
the
bulk
documents
and
our
test.
You
know
it's
not
doing
a
whole
lot,
but
it's
telling
us
that
you
know:
we've
created
this
fake
adapter
and
that
fake
adapter
is
not
implementing
the
pattern.
B
C
C
A
C
B
Yeah
so
tomorrow
we'll
pick
up
at
4
30
and
work
on
the
adapters,
which
will
be
good
and
then
jump
in
the
core,
and
I
I
don't
know
how
long
it'll
take
for
the
adapter
part,
but
then
once
we
get
that
core
won't
take,
but
a
few
minutes.
So
I
think
we
should
be
able
to
wrap
it
up
tomorrow
or
wednesday
and
then
jump
on
on
security
or
something
fun
like
that.
I
don't
know.