►
Description
This community call demo is taken from the SharePoint Framework community call recording on 1st of August 2019. In this video, Vardhaman Deshpande (Content and Code) shows how to use Microsoft Rush to manage complex SharePoint Framework solutions.
"Rush makes life easier for JavaScript developers who build and publish many packages from a common Git repo. If you're looking to break up your giant application into smaller pieces, and you already realized why it doesn't work to put each package in a separate repo... then Rush is for you!"
Presenter - Vardhaman Deshpande (Content and Code) - @vrdmn
You can read more details around the solution from following blog post: https://www.vrdmn.com/2019/04/using-microsoft-rush-to-manage-spfx.html
More details on Microsoft Rush are available from https://rushjs.io/
Full details on the community call from https://developer.microsoft.com/en-us/sharepoint/blogs/sharepoint-framework-community-call-recording-1st-of-august-2019/
More details on the SharePoint dev community calls from http://aka.ms/sppnp.
A
B
Everyone,
my
name,
is
welcome
on
Deshpande
and
and
I
thought
today
we
could
kind
of
discuss,
go
through
Microsoft
Rush
and
then
how
it
can
be
used
to
kind
of
manage
large
s,
P
FX
repositories.
Now
this
perfect
suppositories
could
get
fairly
large,
depending
on
how
you
set
them
up
and
especially
when
it
comes
to
library,
components
and
then
getting
generally
available
soon.
I
think
it
would
be
kind
of
good
to
learn
about
different
ways
to
manage
large
repositories
and
with
with
multiple
library,
components
and
consumer
components
as
well.
B
So
imagine
you're
working
on
a
fairly
large
solution,
and
you
have
something
like
a
structure
like
this,
where
you
have
like
an
organization-wide
utility
component,
which
is
an
SPF
X
library
component,
which
is
used
throughout
your
company.
Then
working
with
like
a
specific
project,
you
create
your
own
library
component
and
then
you
have
certain
consumer
web
parts
and
extensions
which
hook
into
those
library
components
and
then
there's
a
dependency
on
of
there's
a
dependency
on
the
utility
library
in
the
organizational
library
as
well.
B
So,
like
you
can
start
seeing
how
this
this
structure
can
get
fairly
complicated
fairly
quickly,
especially
in
things
like
you
have
to
manage
multiple
node
modules
folder.
If
you're,
if
you
are
using
NPM
I,
know
some
package
managers
like
P
NPM
have
have
other
ways
to
address
that
but
say
if
you're
using
NPM,
then
you
have
to
manage
multiple
node
modules.
Folders.
B
Also,
you
have
to
manage
the
dependency
tree
yourself
like,
for
example,
if
utility
library
gets
updated,
you
have
to
know
which
other
downstream
dependencies
have
to
be
updated
with
that
as
well,
so
that
they
don't
break
and
as
as
kind
of
projects
like
these
get
larger,
it
becomes
harder
and
harder
to
manage
independent
NPM
packages
and
modules.
So
there
are
certain
tools
available
which
kind
of
help
you
help
you
address
this
situation
and
one
of
them
is
Microsoft
rush.
B
If
you
go
to
the
rush
website,
you're
able
to
see
all
the
all
the
different
features,
rush
mix
mix
available
and
it's
used
internally
at
Microsoft
in
certain
products
as
well.
I
will
talk
about
like
more
more
different
tools,
alternatives
to
rush
a
little
bit
later
as
well.
But
this
this
topic
of
this
demo
is
mainly
around
rush.
So
one
thing
we
we
need
to
kind
of
understand
is
a
lot
of
lot
of
benefits
which
you
get
when
you're
working
with
Microsoft
Rush.
Is
that
you
don't?
B
It
manages
all
your
node
modules
of
all
the
different
SP
effects
solutions
in
a
single
location.
It
also
creates
a
single
log
file
and
then
one
once
you
update
in
a
single
command,
it
tries
to
detect
which
of
your
packages
were
updated
and
it
updates
the
relevant
downstream
dependencies
as
well.
So
we'll
see
a
quick
demo.
The
first
demo
is
fairly
simple:
it's
just
a
one
to
one
relationship,
so
there's
one
library
component
and
then
one
SP
effects
web
part
which
which
uses
that
library
component.
B
B
Okay
and
then
I
won't
go
into
how
go
to
the
detail,
steps
of
how
you
can
set
up
rush
I
think
the
website
also
has
great
details
as
well
as
I've
got
them
in
my
blog
post
as
well.
So
once
everything
is
set
up,
and
then
you
update
your
library
component,
we
just
have
to
do
rush
build
and
it
will
start
determining
what
which
packages
in
your
tree
changed
and
it
will.
It
will
update
the
downstream
dependencies
as
well
as
the
packages
immediately.
B
It
also
can
run
built
in
parallel,
so
depending
on
your
CPU
and
how
much
power
it
can
command
right.
Now
you
can
see
there's
only
three
simultaneous
process,
but
we
don't
need
need
those
right
now,
so
it
can
also
update
multiple
packages
in
parallel
if
they
don't
have
dependencies
on
each
other.
So
hopefully
this
will
complete
in
pretty
quickly.
B
B
So
so
gay
going
back
and
doing
another
so
straight
away.
It
will
determine
that
the
library
component
did
not
change,
so
it's
going
to
skip
it
and
it's
going
to
be
only
going
to
go
and
update
the
the
package
which
has
the
web
part
now
behind
the
scenes.
This
is
running
all
your
normal
gulp
bundle
package
solution
commands.
B
You
can
see
the
details
about
that
in
the
blog
post
as
well,
so
just
a
quick
demo
to
show
that
it
only
updates
the
the
packages
which
have
changed
and
yeah.
So
you
can
see
the
in
the
report
that
only
the
web
part
package
was
updated
and
the
library
components
was
skipped
now,
we'll
we'll
see
a
slightly
more
complex
demo
as
well,
where
it's
going
to
kind
of
listen
to,
or
it's
going
to
demo
this
structure
now,
as
I
mentioned,
it
can
also
detect
parallel
builds.
B
So,
for
example,
if
the
organizational
library
component
is
going
to
get
updated,
it
will
update
the
dip
down
string
dependency
as
well,
and
it
will
it
will
kind
of
determine
that
the
second
component
doesn't
need
to
be
updated.
So
it
will
skip
that
as
well.
Along
with
utility
library,
because
that's
not
getting
updated
because
it
doesn't
have
any
dependency
so
going
back,
similar
kind
of
structure
in
the
apps
folder
I
have
two
SPF
x
solutions.
B
One
is
the
first
app
which
has
a
dependency
on
the
directly
on
the
utility
library
and
then
in
the
second
app.
It
has
a
dependency
on
the
organizational
library
and
then,
when
I
go
in
the
libraries
folder,
the
organizational
library
has
a
dependency
on
utilities,
library
as
well.
Now,
when
I
go
here
and
I
update
the
organizational
library,
then
I
do
a
rush
build
again.
B
B
It's
straight
away
going
to
determine
which
which
components
need
to
be
updated.
So,
first
of
all,
it
skipped
the
utility
library
because,
as
you
can
see,
it's
a
top-level
library,
it
doesn't
need
to
change
because
organizational
library
has
changed.
Similarly,
it
it
skipped
the
second
app
as
well,
which
directly
depends
on
the
utility
library,
because
that
doesn't
need
to
change
because
organizational
library
has
changed
and
then
it
will
start,
it
will
start
building
the
packages
which
need
to
change.
B
So,
as
you
can
see
like
it
can
probably
start
imagining
how
how
easy
it
would
be
to
manage
large
repositories
with
many
bundles,
and
you
can
have
multi-level
dependencies
in
it
as
well.
Now.
The
way
it
kind
of
determines
is
to
which
package
packages
should
be
updated
is
due
to
this
file
called
rush
dot
Jason.
So
in
that
this,
this
has
to
be
manually
configured
when
you
setup
rush.
B
So
in
that
you
can
configure
the
name
of
the
package
and
then,
which
folder
is
that
package
going
to
live
in
right
now
and
when,
when
it
traverses,
the
package
store
Jason
file
of
certain
certain
packages
it
determines
which
is
the
dependencies
and
then
it
goes
and
looks
in
that
folder
and
updates
the
packages
accordingly.
Also,
another
nice
thing
to
remember
is
that
it
uses
the
get
change
files
to
get
get
change
tracking
to
determine
which
files
are
updated
and
accordingly
update
the
relevant
packages.
B
So
today,
if
you're
using
another
version,
control
system
like
TF,
we
see,
for
example,
rush-
won't
help
you
in
that.
That
sense
is
of
now
so
I've
got
all
the
details
in
my
in
my
posts
around
like
what
are
the
benefits
and
what
are
the
advantages
and
four
things
to
consider
as
well,
and
I've
got
a
detailed
kind
of
walkthrough
of
how
to
set
up
the
simple,
simple
project
which
we
saw
earlier
as
well.
Now.
One
thing
I
should
mention:
is
this
mono
repository
or
mono
repo
is,
is
not
a
new
concept.
B
It
has
been
in
existence
since
since
a
while.
So
there
are
other
kind
of
packaged
mono
repo
managers
available
as
well,
so
one
of
them
is
learn
now,
which
is
which
is
fairly
fairly
common
and
surkhi
has
got
a
great
post
on
how
to
you
led
not
to
managers
VFX
projects.
So
if
you
go
through
the
post,
you
can
see
that
inside
rjs
and
create
react
app.
All
of
them
use
this.
So.