@ofidj/generator-fidj 1.0.0 → 1.0.1

package/generators/app/templates/typescript/test/server.test.mjs

@@ -0,0 +1,287 @@
+import {execFile} from "node:child_process";
+import {promisify} from "node:util";
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { mkdtemp, rm, writeFile, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHmac } from "node:crypto";
+import { createRequire } from "node:module";
+const { createApp, DataStore } = createRequire(import.meta.url)(
+  "../dist/server.cjs",
+);
+const listen = (server) =>
+  new Promise((resolve) =>
+    server.listen(0, "127.0.0.1", () =>
+      resolve(`http://127.0.0.1:${server.address().port}`),
+    ),
+  );
+const close = (server) => new Promise((resolve) => server.close(resolve));
+const token = (subject, appId = "test-app") =>
+  `header.${Buffer.from(JSON.stringify({ sub: subject, name: subject + "@test.local", aud: appId, roles: ["Owner"] })).toString("base64url")}.signature`;
+
+test("enforces live app roles, identity isolation and scoped privacy over HTTP", async () => {
+  const directory = await mkdtemp(join(tmpdir(), "fidj-data-test-"));
+  const adapterKey = "test-only-privacy-adapter-secret-32-chars";
+  let appUrl;
+  const adapterCall = async (
+    operation,
+    subject,
+    requestId = "departure-maya",
+    overrides = {},
+  ) => {
+    const data = { operation, subject, appId: "test-app", requestId };
+    const timestamp = String(Date.now());
+    const signature = createHmac("sha256", adapterKey)
+      .update(timestamp + "." + JSON.stringify(data))
+      .digest("hex");
+    return fetch(appUrl + "/fidj/privacy", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-fidj-timestamp": timestamp,
+        "x-fidj-signature": signature,
+        ...overrides,
+      },
+      body: JSON.stringify(data),
+    });
+  };
+  const maya = token("maya");
+  const sam = token("sam");
+  const assignments = new Map([
+    [maya, ["Free"]],
+    [sam, ["Editor"]],
+  ]);
+  const consents = new Map();
+  let outage = false;
+  const issuer = createServer(async (req, res) => {
+    const bearer = req.headers.authorization?.slice(7);
+    const roles = assignments.get(bearer);
+    res.setHeader("Content-Type", "application/json");
+    if (outage) {
+      res.writeHead(503);
+      return res.end("{}");
+    }
+    if (!roles) {
+      res.writeHead(403);
+      return res.end("{}");
+    }
+    if (req.url === "/apps/test-app/me")
+      return res.end(
+        JSON.stringify({ roles: roles.map((type) => ({ type })) }),
+      );
+    if (req.url === "/me/apps/test-app/consents/history")
+      return res.end('{"history":[]}');
+    if (req.url === "/me/apps/test-app/consents") {
+      if (req.method === "PUT") {
+        let text = "";
+        for await (const chunk of req) text += chunk;
+        consents.set(bearer, JSON.parse(text));
+      }
+      return res.end(
+        JSON.stringify({
+          ...(consents.get(bearer) || { terms: true }),
+          appDataConnected: true,
+        }),
+      );
+    }
+    if (req.url === "/me/apps/test-app/export")
+      return res.end(JSON.stringify({ consent: consents.get(bearer) }));
+    if (req.url === "/me/apps/test-app" && req.method === "DELETE") {
+      const erased = await adapterCall(
+        "erase",
+        JSON.parse(Buffer.from(bearer.split(".")[1], "base64url")).sub,
+      );
+      if (!erased.ok) {
+        res.writeHead(202);
+        return res.end('{"status":"pending"}');
+      }
+      assignments.delete(bearer);
+      return res.end('{"status":"completed"}');
+    }
+    res.writeHead(404);
+    res.end("{}");
+  });
+  const apiEndpoint = await listen(issuer);
+  const settings = {
+    appId: "test-app",
+    apiEndpoint,
+    dashboardUrl: "https://fidj.ovh",
+    title: "Test app",
+    localDemo: false,
+  };
+  const persistence = new DataStore(directory, "test-app");
+  const erase = persistence.erase.bind(persistence);
+  let storageUnavailable = false;
+  persistence.erase = async (...args) => {
+    if (storageUnavailable) throw new Error("Simulated storage outage");
+    return erase(...args);
+  };
+  let app = createApp(settings, {
+    dataDir: directory,
+    adapterKey,
+    store: persistence,
+  });
+  let url = await listen(app);
+  appUrl = url;
+  const call = (path, bearer = maya, method = "GET", data) =>
+    fetch(url + "/api/" + path, {
+      method,
+      headers: {
+        Authorization: "Bearer " + bearer,
+        "Content-Type": "application/json",
+      },
+      body: data === undefined ? undefined : JSON.stringify(data),
+    });
+  try {
+    assert.equal((await fetch(url + "/api/notes")).status, 401);
+    assert.equal(
+      (await call("session", token("maya", "other-app"))).status,
+      401,
+    );
+    assert.equal((await call("session", maya + "tampered")).status, 401);
+    assert.equal(
+      (await call("notes", maya, "POST", { title: "Hello", body: "Private" }))
+        .status,
+      403,
+    );
+    assignments.set(maya, ["Editor"]);
+    assert.equal(
+      (await call("notes", maya, "POST", { title: "Hello", body: "Private" }))
+        .status,
+      201,
+    );
+    assert.equal((await (await call("notes", sam)).json()).notes.length, 0);
+    assert.equal((await (await call("notes")).json()).notes.length, 1);
+    await call("notes", sam, "POST", { title: "Sam only", body: "Preserve" });
+    await close(app);
+    app = createApp(settings, {
+      dataDir: directory,
+      adapterKey,
+      store: persistence,
+    });
+    url = await listen(app);
+    appUrl = url;
+    assert.equal((await (await call("notes")).json()).notes[0].title, "Hello");
+    assert.equal(
+      (
+        await adapterCall("export", "maya", "export-test", {
+          "x-fidj-signature": "0".repeat(64),
+        })
+      ).status,
+      401,
+    );
+    assert.equal(
+      (
+        await adapterCall("export", "maya", "export-test", {
+          "x-fidj-timestamp": "1",
+        })
+      ).status,
+      401,
+    );
+    assert.equal(
+      (await (await adapterCall("export", "maya", "export-test")).json()).data
+        .notes.length,
+      1,
+    );
+    assert.equal(
+      (await (await adapterCall("export", "sam", "export-sam")).json()).data
+        .notes.length,
+      1,
+    );
+    assert.equal((await fetch(url + "/.fidj-data/data.json")).status, 404);
+    const readiness = await (await adapterCall("check", "readiness-check", "check-test")).json();
+    assert.equal(readiness.storage, "ready");
+    assert.deepEqual(readiness.capabilities, ["export", "erase"]);
+    const checked = await promisify(execFile)(process.execPath, ["scripts/privacy-check.mjs"], {env: {...process.env, FIDJ_APP_ID: "test-app", FIDJ_APP_URL: url, FIDJ_PRIVACY_ADAPTER_KEY: adapterKey}});
+    assert.match(checked.stdout, /Ready:/);
+    await assert.rejects(promisify(execFile)(process.execPath, ["scripts/privacy-check.mjs"], {env: {...process.env, FIDJ_APP_ID: "test-app", FIDJ_APP_URL: url, FIDJ_PRIVACY_ADAPTER_KEY: "wrong-key-that-is-long-enough-for-check"}}));
+    assert.equal(
+      (await (await fetch(url + "/api/config")).json()).adapterKey,
+      undefined,
+    );
+    assignments.set(maya, ["Free"]);
+    assert.equal(
+      (await call("notes", maya, "POST", { title: "Denied", body: "" })).status,
+      403,
+    );
+    assert.equal(
+      (await call("privacy", maya, "PUT", { analytics: true })).status,
+      200,
+    );
+    assert.equal(consents.get(maya).analytics, true);
+    assert.equal(consents.has(sam), false);
+    assert.equal(
+      (await (await call("privacy/export")).json()).app.notes.length,
+      1,
+    );
+    outage = true;
+    assert.equal((await call("notes")).status, 503);
+    outage = false;
+    assert.equal(
+      (await call("privacy/leave", maya, "DELETE", { confirm: "other-app" }))
+        .status,
+      400,
+    );
+    storageUnavailable = true;
+    assert.equal((await adapterCall("erase", "maya")).status, 500);
+    assert.equal((await (await call("notes")).json()).notes.length, 1);
+    storageUnavailable = false;
+    await writeFile(
+      join(directory, "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa.tmp"),
+      "Interrupted private data copy",
+    );
+    assert.equal(
+      (await call("privacy/leave", maya, "DELETE", { confirm: "test-app" }))
+        .status,
+      200,
+    );
+    assert.equal((await call("notes")).status, 401);
+    assert.equal(
+      (await readdir(directory)).filter((name) => name.endsWith(".tmp")).length,
+      0,
+    );
+    assignments.set(maya, ["Free"]);
+    assert.equal((await (await call("notes")).json()).notes.length, 0);
+    assert.equal((await call("session", sam)).status, 200);
+    assert.equal(
+      (await (await call("notes", sam)).json()).notes[0].title,
+      "Sam only",
+    );
+    assignments.set(maya, ["Editor"]);
+    await call("notes", maya, "POST", {
+      title: "New membership",
+      body: "Keep this",
+    });
+    await close(app);
+    app = createApp(settings, {
+      dataDir: directory,
+      adapterKey,
+      store: persistence,
+    });
+    url = await listen(app);
+    appUrl = url;
+    assert.equal((await adapterCall("erase", "maya")).status, 200);
+    assert.equal(
+      (await (await call("notes")).json()).notes[0].title,
+      "New membership",
+    );
+    assert.equal((await adapterCall("erase", "sam")).status, 500);
+    const store = new DataStore(directory, "test-app");
+    await assert.rejects(
+      store.add(
+        "maya",
+        { id: "denied", title: "Race", body: "", createdAt: "" },
+        async () => {
+          throw new Error("Revoked during operation");
+        },
+      ),
+    );
+    assert.equal((await store.notes("maya")).length, 1);
+  } finally {
+    await close(app);
+    await close(issuer);
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/generators/app/templates/typescript/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "noEmit": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts", "server/**/*.ts"]
+}

package/lib/app-module.cjs

@@ -0,0 +1,59 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function inspectModule(source, entry = "index.html", destination) {
+  const root = fs.realpathSync(path.resolve(source));
+  const output = path.resolve(destination);
+  if (!fs.statSync(root).isDirectory())
+    throw new Error("Module must be a built website directory.");
+  if (
+    output === root ||
+    output.startsWith(root + path.sep) ||
+    root.startsWith(output + path.sep)
+  )
+    throw new Error(
+      "Module source and generated destination must not contain each other.",
+    );
+  if (/^(?:[a-z]+:|\/\/)/i.test(entry))
+    throw new Error("Module entry must be relative.");
+  const url = new URL(entry, "https://module.invalid/module/");
+  if (
+    url.origin !== "https://module.invalid" ||
+    !url.pathname.startsWith("/module/") ||
+    url.search ||
+    entry.startsWith("/")
+  )
+    throw new Error(
+      "Module entry must be a relative HTML path inside the module.",
+    );
+  const file = decodeURIComponent(url.pathname.slice("/module/".length));
+  if (
+    !file.endsWith(".html") ||
+    file.split("/").some((part) => part === "..") ||
+    file.includes("\\")
+  )
+    throw new Error(
+      "Module entry must be a relative HTML path inside the module.",
+    );
+  if (!fs.statSync(path.join(root, file)).isFile())
+    throw new Error("Module entry does not exist.");
+  if (!fs.readFileSync(path.join(root, file), "utf8").includes("</head>"))
+    throw new Error("Module entry must have an HTML head.");
+  const visit = (directory) => {
+    for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (item.isSymbolicLink())
+        throw new Error("Built modules must not contain symbolic links.");
+      if (
+        [".git", "node_modules", ".env"].includes(item.name) ||
+        item.name.startsWith(".env.")
+      )
+        throw new Error(
+          "Supply only the module's public build output, without environment or dependency files.",
+        );
+      if (item.isDirectory()) visit(path.join(directory, item.name));
+    }
+  };
+  visit(root);
+  return { root, file, entry: "./module/" + file + url.hash };
+}
+module.exports = { inspectModule };

package/lib/scaffold.cjs

@@ -0,0 +1,145 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { inspectModule } = require("./app-module.cjs");
+const templateRoot = path.join(
+  __dirname,
+  "../generators/app/templates/typescript",
+);
+
+function scaffold(destination, options) {
+  const anonymous = options.anonymous ?? true;
+  if (![true, false, "true", "false"].includes(anonymous))
+    throw new Error("--anonymous must be true or false.");
+  const name = options.name || path.basename(path.resolve(destination));
+  if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(name))
+    throw new Error(
+      "Use a lowercase project name with letters, numbers and hyphens.",
+    );
+  if (!/^[a-zA-Z0-9_-]+$/.test(options.appId || ""))
+    throw new Error("Supply your app’s public fidjId with --app-id.");
+  const api = new URL(options.apiEndpoint || "https://api.sandbox.fidj.ovh/v3");
+  if (
+    api.username ||
+    api.password ||
+    api.search ||
+    api.hash ||
+    !["http:", "https:"].includes(api.protocol)
+  )
+    throw new Error(
+      "Use an API URL without credentials, a query or a fragment.",
+    );
+  if (
+    api.protocol === "http:" &&
+    !["localhost", "127.0.0.1", "[::1]"].includes(api.hostname)
+  )
+    throw new Error("Use HTTPS for a remote API.");
+  if (options.oidcIssuer) {
+    const issuer = new URL(options.oidcIssuer);
+    if (issuer.origin !== api.origin || issuer.pathname !== "/oidc" || issuer.hash || issuer.search || issuer.username || issuer.password) throw new Error("OIDC issuer must share the API origin and use /oidc.");
+    if (options.content === undefined && !options.module) throw new Error("OIDC currently requires a content app or console module.");
+  }
+  const title = options.title || name;
+  if (/[\r\n]/.test(title)) throw new Error("Title must be one line.");
+  if (
+    options.domain &&
+    !/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/i.test(options.domain)
+  )
+    throw new Error("Domain must be a hostname, without a scheme or path.");
+  const dir = path.resolve(destination);
+  const appModule = options.module
+    ? inspectModule(options.module, options.moduleEntry, dir)
+    : null;
+  if (options.moduleEntry && !appModule)
+    throw new Error("--module-entry requires --module.");
+  if (options.replace && fs.existsSync(dir)) {
+    if (!fs.existsSync(path.join(dir, ".fidj-generated")))
+      throw new Error(
+        "Replacement requires a .fidj-generated marker in the destination.",
+      );
+    fs.rmSync(dir, { recursive: true });
+  }
+  if (fs.existsSync(dir) && fs.readdirSync(dir).length)
+    throw new Error(
+      "Destination must be empty. Existing projects are never overwritten.",
+    );
+  fs.mkdirSync(dir, { recursive: true });
+  fs.cpSync(templateRoot, dir, { recursive: true });
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(dir, "package.json"), "utf8"),
+  );
+  pkg.name = name;
+  if (options.sdkPath) {
+    const sdkPath = path.resolve(options.sdkPath);
+    const sdk = JSON.parse(
+      fs.readFileSync(path.join(sdkPath, "package.json"), "utf8"),
+    );
+    if (sdk.name !== "@ofidj/node")
+      throw new Error("SDK path must contain a built @ofidj/node package.");
+    pkg.dependencies["@ofidj/node"] = "file:" + sdkPath;
+  }
+  fs.writeFileSync(
+    path.join(dir, "package.json"),
+    JSON.stringify(pkg, null, 2) + "\n",
+  );
+  fs.renameSync(path.join(dir, "gitignore"), path.join(dir, ".gitignore"));
+  const settings = `FIDJ_APP_ID=${options.appId}\nFIDJ_API_ENDPOINT=${api.href.replace(/\/$/, "")}\nFIDJ_DASHBOARD_URL=https://fidj.ovh\nAPP_TITLE=${title}\nPORT=8200\nHOST=127.0.0.1\nLOCAL_DEMO=false\nFIDJ_DATA_DIR=../.fidj-data/${name}\nFIDJ_PRIVACY_ADAPTER_KEY=\n`;
+  const localApi = options.local
+    ? "http://localhost:3201/v3"
+    : api.href.replace(/\/$/, "");
+  const configuration = {
+    appId: options.appId,
+    oidcIssuer: options.oidcIssuer || null,
+    apiEndpoint: localApi,
+    dashboardUrl: options.local ? "http://localhost:4200" : "https://fidj.ovh",
+    title,
+    localDemo: Boolean(options.local),
+    allowAnonymous: anonymous === true || anonymous === "true",
+    welcome: options.welcome || title,
+    description:
+      options.description ||
+      "A space to explore, with an account that puts you in control.",
+    content: appModule ? "" : options.content,
+    moduleEntry: appModule?.entry || "",
+    domain: options.domain,
+  };
+  if (appModule) {
+    fs.cpSync(appModule.root, path.join(dir, "public/module"), {
+      recursive: true,
+    });
+    const entryFile = path.join(dir, "public/module", appModule.file);
+    const relativeSignin =
+      path.posix.relative(
+        path.posix.dirname("module/" + appModule.file),
+        "index.html",
+      ) + "#/signin";
+    const html = fs.readFileSync(entryFile, "utf8");
+    if (!html.includes("</head>"))
+      throw new Error("Module entry must have an HTML head.");
+    fs.writeFileSync(
+      entryFile,
+      html.replace(
+        "</head>",
+        `<meta name="fidj-signin" content="${relativeSignin}"></head>`,
+      ),
+    );
+  }
+  fs.writeFileSync(
+    path.join(dir, "app.config.json"),
+    JSON.stringify(configuration, null, 2) + "\n",
+  );
+  const env = settings
+    .replace(api.href.replace(/\/$/, ""), localApi)
+    .replace(
+      "FIDJ_DASHBOARD_URL=https://fidj.ovh",
+      `FIDJ_DASHBOARD_URL=${configuration.dashboardUrl}`,
+    )
+    .replace("LOCAL_DEMO=false", `LOCAL_DEMO=${configuration.localDemo}`);
+  fs.writeFileSync(path.join(dir, ".env.example"), env);
+  fs.writeFileSync(path.join(dir, ".env"), env);
+  fs.writeFileSync(
+    path.join(dir, ".fidj-generated"),
+    "Disposable generator output.\n",
+  );
+  return dir;
+}
+module.exports = { scaffold };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ofidj/generator-fidj",
-  "version": "1.0.0",
-  "description": "build great mobile angular ionic apps based on fidj.ovh authentication",
+  "version": "1.0.1",
+  "description": "Generate a TypeScript app with Fidj sign-in, live server-side roles and per-app privacy.",
   "homepage": "https://fidj.ovh",
   "bugs": {
     "url": "https://github.com/ofidj/generator-fidj/issues"
@@ -10,9 +10,13 @@
     "access": "public"
   },
   "files": [
-    "generators"
+    "bin",
+    "lib",
+    "generators",
+    "!generators/app/templates/app2018",
+    "!generators/app/templates/app2021"
   ],
-  "main": "generators/index.js",
+  "main": "./lib/scaffold.cjs",
   "keywords": [
     "fidj",
     "angular",
@@ -20,13 +24,9 @@
     "yeoman-generator"
   ],
   "dependencies": {
-    "chalk": "^3.0.0",
-    "yeoman-generator": "^4.12.0",
-    "yosay": "^2.0.2"
-  },
-  "devDependencies": {
-    "tslint": "^6.1.3"
+    "yeoman-generator": "^4.12.0"
   },
+  "devDependencies": {},
   "eslintConfig": {
     "extends": "xo-space",
     "env": {
@@ -35,7 +35,13 @@
   },
   "repository": "https://github.com/ofidj/generator-fidj.git",
   "scripts": {
-    "test": "echo nope"
+    "test": "node --test test/*.test.cjs"
+  },
+  "license": "MIT",
+  "bin": {
+    "create-fidj": "bin/create-fidj.cjs"
   },
-  "license": "MIT"
+  "engines": {
+    "node": ">=22"
+  }
 }

package/generators/app/templates/app2018/.travis.yml

@@ -1,35 +0,0 @@
-language:
-  - node_js
-node_js:
-   - 6.11.5
-branches:
-  only:
-    - master
-install:
- - git config remote.origin.fetch +refs/heads/*:refs/remotes/origin/*
- - git fetch --tags --depth=10000
- - npm install
- - npm version patch -m "[ci skip] version bumped %s"
-script:
- - npm test
- - npm run build
-after_success:
- - git remote add upstream "https://${GH_TOKEN}@github.com/${GH_REPO}.git"
- - git add .
- - git commit -m "[ci skip] version ok"
- - git push upstream HEAD:master
- - rm -r src
- - rm -r tests
- - rm -r coverage
- - rm -r node_modules
- - rm www/.gitignore
-deploy:
-  provider: pages
-  skip-cleanup: true
-  github-token: $GH_TOKEN
-  keep-history: true
-  on:
-    branch: master
-env:
-  global:
-    - GH_REPO: "<%= appUserName %>/<%= appName %>"

package/generators/app/templates/app2018/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2018 fidj.ovh team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/generators/app/templates/app2018/Procfile

@@ -1 +0,0 @@
-web: node web.js

package/generators/app/templates/app2018/README.md

@@ -1,49 +0,0 @@
-# <%= appName %>
-
-> <%= appDescription %>
-
-## Prerequisite
-
-Look at [mat's gist](https://gist.github.com/mlefree/2156f66dfb441f107bef157dde56a836),
-in order to check your node, cordova, ionic and yeoman installation.
-
-[![Fidj.ovh Status][fidj-image]][fidj-url]
-[![Build Status][travis-image]][travis-url]
-
-[![video][youtube-img]][youtube-video]
-
-## Build it
-
-Clone and install the project
-
-```bash
-npm install
-```
-
-and then launch on your device
-
-```bash
-npm run ios
-# then ready to launch your app (./platforms/ios/*.xcodeproj) in XCode
-```
-
-## Deploy
-
-Follow this https://ionicframework.com/docs/intro/deploying.
-
-### For test on Github or Heroku
-
-It's up to you if you want to use your www generated folder as static page.You can also use the [fidj-sandbox](https://sss) before any production; 2 variables are available for that :
-
-```bash
-FIDJ_APP_ID # force your fidj app Id with your sandbox's one
-FIDJ_APP_PROD # 'true' by default, 'false' to test it on sandbox
-```
-
-[fidj-image]: https://fidj.ovh/_/<%= appName %>/badges/github.svg
-[fidj-url]: https://fidj.ovh/_/<%= appName %>
-[youtube-img]: http://img.youtube.com/vi/0FbnCWWg_NY/0.jpg
-[youtube-video]: https://www.youtube.com/embed/0FbnCWWg_NY?autoplay=true
-[travis-image]: https://travis-ci.org/<%=appUserName %>/<%= appName %>.svg?branch=master
-[travis-url]: https://travis-ci.org/<%=appUserName %>/<%= appName %>
-