[Patel] SPFx: An ISV Insight into latest Microsoft's customization model

SPFx: An ISV Insight to Microsoft’s latest
customization model
By: Shai Petel

Shai Petel
Director of Research and Development at KWizCom
MCT, MCPD
6 times MVP: SharePoint (2011-2016)
shai@kwizcom.com | @shaibs | http://kwizcom.blogspot.com

Focus:
 Publishing versions, upgrades
 Pushing updates through CDN
 Shared code and external libraries
 Custom PropertyPane properties
 Code, code, code.

SHAREPOINT DEVELOPMENT
MODELS
Overview of extensibility opportunities in SharePoint’s history

SharePoint Development Models
2001
STS
SPS
2003
SPS
WSS
2007
MOSS
WSS
2010
SharePoint Foundation
SharePoint Server
2013
SharePoint Foundation
SharePoint Server
SPO
SharePoint Online
Group sites *
2016
SharePoint Server

SharePoint Development Models
 2001
– ASP (no, I didn’t forget the
.Net)
– Page parts, tokens (_wpq_,
_wpr_)
– No clear packaging and
deployment
 2003
– Web parts (ASP.Net custom
controls)
– Packaged in CAB
 2007
– Features
– WSP package
 2010
– Timer jobs
– Sandbox
 2013
– SharePoint hosted apps add-
ins
– Provider hosted apps add-ins
– JSLink / CSR
 SPO
– SharePoint hosted apps add-
ins
– Provider hosted apps add-ins
– JSLink / CSR No code sandbox
solutions
– SharePoint Framework (SPFx)

WHAT IS SPFX?
Brief explanation of the SharePoint Framework

What is SPFx?
“a Page and Part model enables fully supported client-
side development for building SharePoint experiences,
easy integration with the SharePoint data and support
for open source tooling development.”

What is SPFx? - advantages
Runs in the context of the current user. No iFrames
There is a life cycle that the developer is involved in
It is framework agnostic *
Open source tool chain
Performance
Solutions approved by the tenant admin (or their
delegates)
Classic & modern pages
Can be used in noscript sites

What is SPFx? - disadvantages
SPO: up-to-date - on prem: only 2016, older build
Extremely big learning curve
Limited artifact types supported
Publishing updates ~
No support for the app store

DOES IT DELIVER?
SPFx compared to previous generations

CHOICE OF UI FRAMEWORK
How would you render the UI of your web part?

Choice of UI framework
 SPFx is framework agnostic by design. Really?
 This is the most important decision when building a
new project

ReactJS - the clear leader & first class citizen
 This is the engine MSFT use themselves
 The PropertyPane is built on react, and the engine
wrapping your WebPart is too.
 The only Office UI Fabric components actively
supported by Microsoft

KnockoutJS
 Good when you need dynamic templates (i.e. user
supply / customize HTML output)
 Lack of fabric components. Use FabricJS
 Building in --ship mode removes KO comments

Handlebars, angular, etc…
Experiment, choose the one that fits your skills and
needs.
AngularJS has a good community supported
office UI fabric components library.

Building your solution
Building a new project
 Create a folder
 Run “yo @microsoft/sharepoint”
 Set name, description

 Select “WebPart”

 Select your JavaScript framework

Add several artifacts to a single package
 Currently only web parts are supported on prem
 Application Customizer, Field Customizer and
ListView Command Set – very limited & online only
 Add more artifacts by running
“yo @microsoft/sharepoint”
inside an existing project folder

PUBLISHING
Publishing your SPFx solution

Publishing
Content Delivery Network (CDN)
 Specify CDN in config/write-manifests.json
 Host script files, css, images, html
 Push minor fixes to clients
 Non-ISVs on SPO can use Office 365 public CDN

Publishing
Control production build file names
Running gulp --ship will produce a bundle file for
production:
 Default: react-web-
part.bundle_a4b2ffc1a3b03f7ce4b5bd78bdd7ac62.js
 Recommend: react-web-part.1.0.0.0.js

Publishing
Publish a package
1. Update web part version in config/package-solution.json
2. Run gulp --ship
3. Go to temp/deploy folder
4. Rename the JS file (I use {project}.{version}.js)
5. Edit the json file: replace the bundle JS file to the new name *
6. Run gulp package-solution --ship
7. Take your new packages from the SharePoint/solution folder
8. Drop your new JS to your CDN **
[optional steps]

Publishing
Publishing updates: Do I need to release a new
package?
 You might be able to push updates to your customers
 Check if your new version is backward compatible
 Track version via a static variable

Publishing
Publishing updates: Update a package
 When a new package is needed – follow “publish a
package” steps
 When a new package is not needed
1. Update BuildVersion in your code *
2. Run gulp --ship
3. Go to temp/deploy folder
4. Copy the new JS file content into your existing file on your CDN
5. To use your own minifier, drop the --ship flag, take the file from
the dist folder

Publishing
Installing / upgrading package
1. Upload package to the App Catalog
2. Trust the app
3. Fixed? A new version: delete old package first

DEVELOPMENT OPTIONS
Dev time environments and options

Development options - local workbench
gulp serve
https://localhost:4321/temp/workbench.html

Development options – online workbench
gulp serve --nobrowser
{spo site}/_layouts/15/workbench.aspx

Development options – classic/modern page
1. gulp --ship
2. gulp package-solution --ship
3. Publish to CDN
4. Deploy to catalog
5. Add app to your site*

Development options
Debugging using VSCode in Chrome
 Open VSCode, View->Extensions
 Install “Debugger for chrome”

Development options
Debugging using VSCode in Chrome
 Create launch.json
 Select your configuration
 Start gulp serve --nobrowser
 Press F5

DEPENDENCIES
Using npm modules
External dependencies
Legacy script (global)

Dependencies - npm
Bundling npm modules
 When you wish to use an npm available module
 If it is a small file, and not reused across many different
components
* Bundling includes this entire module inside your JS file.

Dependencies - npm
How?
 npm install {package} --save
 tsd install {package} --save (or create your own
typings {package}.d.ts)
In your web part code:
 import * as {object} from ‘{package}’
 import {object} from ‘{package}’

Dependencies - npm
External npm modules
 When you wish to use an npm available module
 If it is a large file, or reused across many different
components
* External modules will be loaded from a CDN

Dependencies - npm
How?
 Follow previous steps to load the npm module
 Mark this module as external, to prevent bundling:
– Edit config/config.json
– Add this under “externals” object:
“<package>”: “{path to js file}”

Dependencies - npm
Important!
 .gitignore excludes node_modules folder
 run “npm install” when moving computers
 Dependencies change and your project may break as
a result - npm shrinkwrap!

Dependencies – global library
Loading a legacy script file using config.json
 When you want to load an external script file from a CDN
 Add it as an external (with a global declaration if needed)
 Import it in your web part
 Optionally, create typings for your global.
module declare ‘extLib’{…}
 Alternatively, you can declare it as type any:
declare var extLib: any;

Loading a legacy script file programmatically
 When you don’t want to change your package
signature, or when you want to load it conditionally
 When loading an external script file from a CDN

Loading a legacy script file programmatically
How?
 Declare its global:
declare var kwfabric: any;
 Use a promise to load it, execute your code once the promise
resolves:
SPComponentLoader.loadScript(`https://apps.kwizcom.c
om/libs/office-ui-fabric-
js/1.4.0/js/fabric.js?prefix=kw`, {
globalExportsName: 'kwfabric' }).then((p: any) => {
//use kwfabric
});

Dependencies –fabric js
Using Office UI Fabric JS
 If you can, use react. It comes with amazing support
for Fabric UI.
 If not, I recommend using Fabric JS.
 Optionally, use KWizCom’s hosted branch of Office UI
Fabric JS:
http://kwizcom.blogspot.ca/2017/03/using-office-ui-
fabric-js-in-spfx.html

SHARED REUSABLE CODE
Reuse your code between different SPFx projects

Shared Reusable Code
 Create folder for your shared code
 If you plan to use type script
 Use your code relatively to your project folder

– Install dependencies manually:
npm install @microsoft/sp-core-library@~1.4.0
npm install @microsoft/sp-webpart-base@~1.4.0
– add tsconfig.json, run tsc to compile

import Utilities from '../../../../SharedCode/Utilities';

Consider creating an npm package
Benefits: great versioning and manageability
Disadvantages: overhead in managing the package
and publishing updates

Shared Reusable Code - npm
Creating a new package
 Run “npm init”
 Edit package.json, add dependencies
 run “npm install”
 If you plan to use type script:
– Add tsconfig.json
– Run tsc to build JS files from TS
– Specify "typings" in your package.json

Using your new package
 Edit SPFx package dependencies, add your package:
"kwizcom-license": "file:../kwizcom-license“
 Bundled by default, should you mark as external?
– Plan on using this package from several different projects?
– Its JS file is large?
 How?
– Edit config/config.json add to externals:
"kwizcom-license":
https://kwizcom.sharepoint.com/sites/s/cdn/License.js
– Now, you can also push minor updates/fixes without having to re-
publish all your projects (when you keep backward compatibility).

Publishing updates?
 Update version number in package.json
 Run “npm update” everywhere you used it to update
the package

Consuming data
Connecting to data
 SharePoint
 Microsoft Graph
* Local workbench not supported

Consuming data
Requesting SharePoint content
 Use SPHttpClient (this.context.spHttpClient) post/get
to make rest requests
 Load JSOM into your SPFx
 DO NOT try to use the JSOM global objects. No one
guarantees they will be there in modern pages/other
pages.

Consuming data
What is Microsoft Graph API?
 Graph API is a rest end point for all of your users
O365 services.
 This includes access to his OneDrive, Mail, Calendar,
Contacts, SharePoint, and the list goes on.

Consuming data
Requesting Graph content
 Today – do it yourself. Register an application for graph,
request the trust/permissions you need, and make rest
requests.
 Soon – Microsoft will share one token/key we can all use
for basic read access
– Use GraphHttpClient/MSGraphClient (preview)
– Will automatically use a shared available key/token, with limited
set of permissions
– This token will be limited to accepting requests ONLY from
SharePoint online hosted sites, as a security measure.

ADVANCED PROPERTYPANE
What can you do with the PropertyPane?
Building custom controls

Advanced PropertyPane
Basic concepts
 Rendered based off a dynamic JSON definition
object.
 The tool part will re-render when changing a
dropdown value, or when clicking a button.
 When a property changes, it will update your web
part by re-calling the “render” event.
 Basic structure:
– Pages -> Groups -> Properties -> Property

Advanced concepts - Validations
 onGetErrorMessage return error message string, or
function returning promise.
 During validation, you can control and change other
properties.
 In most cases, it is best to fire on change event to
notify SharePoint of the change.

Advanced concepts - Custom controls
 You can create your own controls for the property
pane
 Use the render method to render your own controls
 Get configuration info from the web part, such as
context, label and where to store your values.
 Notify the web part on value changes (You will need
to create that logic – see next slide)

Advanced concepts - Trigger on change
 First, add the two helper function:
import { get, update } from "@microsoft/sp-lodash-subset";
 Create a handler for your property “on change”
private onPropertyChange(propertyPath: string, newValue: any):
void {
const oldValue: any = get(this.properties, propertyPath);
update(this.properties, propertyPath, (): any => { return
newValue; });
this.onPropertyPaneFieldChanged(propertyPath, oldValue,
newValue);
if (!this.disableReactivePropertyChanges)
this.render();//update the webpart
}

 “this.properties” will get serialized and saved when
your web part is saved. No matter how or what
changed its value.
 Write your own designer logic: popup, panels or
inline. Show it when your web part is in edit mode:
if (this.displayMode === core.DisplayMode.Edit)

Example: custom designer

UPDATING SPFX FRAMEWORK
How to get updates to SPFx?

Updating SPFx framework
Upgrading SPFx version is a challenge
 Pre-GA, it meant building a new project and moving
your code
 Promised this will stop after GA *

Updating SPFx framework
Dependencies
 In theory, as simple as updating package.json and
running npm install/update
 In practice, involves a lot of praying, occasionally deleting
node_modules, and dealing with unexpected errors in
dependencies
 Some dependencies are still global, but that will pass

Helpful tips
Open integrated terminal in VSCode

Add import statements
You don’t have to type the import yourself, look for the
yellow bulb icon when standing on an unrecognized
element:

Helpful tips
Delete/exclude node_modules from your source
control / when zipping the project.
Demo project size:
646MB, 86K files.
Without node_modules:
1.75MB, 138 files.

Helpful tips
Get used to memorizing commands…
 gulp = build
 gulp --ship = build in production
 gulp trust-dev-cert/untrust-dev-cert = trust the local
certificate
 gulp package-solution = create package
 gulp serve = start local server
 code . = open VSCode in current folder

Helpful tips
 Get used to seeing warnings
in the output of the different
commands, especially npm-
install.
 Errors – you should resolve or
something will be broken.
 Warnings during build (gulp)
may come from your code so
you should fix these (missing
semicolon, unneeded import,
etc)

QUESTIONS?
follow up:
shai@kwizcom.com
kwizcom.blogspot.com

[Patel] SPFx: An ISV Insight into latest Microsoft's customization model

More Related Content

What's hot (20)

Similar to [Patel] SPFx: An ISV Insight into latest Microsoft's customization model (20)

More from European Collaboration Summit (20)

Recently uploaded (20)

[Patel] SPFx: An ISV Insight into latest Microsoft's customization model

Editor's Notes