@data-fair/dev-server 2.0.2 → 2.0.3

package/config/custom-environment-variables.js

@@ -0,0 +1,18 @@
+export default {
+  dataFair: {
+    url: 'DATAFAIR_URL',
+    owner: {
+      type: 'DATAFAIR_OWNER_TYPE',
+      id: 'DATAFAIR_OWNER_ID',
+      department: 'DATAFAIR_OWNER_DEPARTMENT'
+    },
+    apiKey: 'DATAFAIR_API_KEY'
+  },
+  app: {
+    url: 'APP_URL',
+    proxyPaths: {
+      __name: 'APP_PROXY_PATHS',
+      __format: 'json'
+    },
+  }
+}

package/config/default.js

@@ -0,0 +1,17 @@
+export default {
+  port: 5888,
+  dataFair: {
+    url: 'https://koumoul.com/data-fair',
+    owner: {
+      type: 'organization',
+      id: '5a5dc47163ebd4a6f438589b',
+      department: null
+    },
+    apiKey: null
+  },
+  app: {
+    url: 'http://localhost:3000',
+    proxyPaths: ['/_nuxt/']
+  },
+  serveUi: true
+}

package/config/development.js

@@ -0,0 +1,3 @@
+export default {
+  serveUi: false
+}

package/config/production.js

@@ -0,0 +1 @@
+export default {}

package/config/type/.type/index.d.ts

@@ -0,0 +1,27 @@
+
+export const schemaExports: string[]
+
+// see https://github.com/bcherny/json-schema-to-typescript/issues/439 if some types are not exported
+export type DevServerConfig = {
+  port: number;
+  dataFair: {
+    url: string;
+    owner: {
+      type: string;
+      id: string;
+      department?: string;
+    };
+    apiKey?: string;
+  };
+  app: {
+    url: string;
+    proxyPaths: string[];
+  };
+  serveUi?: boolean;
+}
+
+
+export declare function validate(data: any): data is DevServerConfig
+export declare function assertValid(data: any, options?: import('@data-fair/lib-validation').AssertValidOptions): asserts data is DevServerConfig
+export declare function returnValid(data: any, options?: import('@data-fair/lib-validation').AssertValidOptions): DevServerConfig
+      

package/config/type/.type/index.js

@@ -0,0 +1,19 @@
+/* eslint-disable */
+
+
+import validate from './validate.js'
+import { assertValid as assertValidGeneric } from '@data-fair/lib-validation'
+
+export const schemaExports = [
+  "types",
+  "validate"
+]
+
+export { validate } from './validate.js'
+export function assertValid(data, options) {
+  assertValidGeneric(validate, data, options)
+}
+export function returnValid(data, options) {
+  assertValid(data, options)
+  return data
+}

package/config/type/.type/validate.js

@@ -0,0 +1,541 @@
+/* eslint-disable */
+// @ts-nocheck
+
+"use strict";
+export const validate = validate14;
+export default validate14;
+const schema16 = {"$id":"https://github.com/data-fair/dev-server/config","x-exports":["types","validate"],"x-ajv":{"coerceTypes":"array"},"x-jstt":{"additionalProperties":false},"type":"object","title":"Dev server config","required":["port","dataFair","app"],"properties":{"port":{"type":"number"},"dataFair":{"type":"object","required":["url","owner"],"properties":{"url":{"type":"string"},"owner":{"type":"object","required":["type","id"],"properties":{"type":{"type":"string"},"id":{"type":"string"},"department":{"type":"string"}}},"apiKey":{"type":"string"}}},"app":{"type":"object","required":["url","proxyPaths"],"properties":{"url":{"type":"string"},"proxyPaths":{"type":"array","items":{"type":"string"}}}},"serveUi":{"type":"boolean"}}};
+
+function validate14(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){
+/*# sourceURL="https://github.com/data-fair/dev-server/config" */;
+let vErrors = null;
+let errors = 0;
+if(data && typeof data == "object" && !Array.isArray(data)){
+if(data.port === undefined){
+const err0 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "port"},message:"must have required property '"+"port"+"'"};
+if(vErrors === null){
+vErrors = [err0];
+}
+else {
+vErrors.push(err0);
+}
+errors++;
+}
+if(data.dataFair === undefined){
+const err1 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "dataFair"},message:"must have required property '"+"dataFair"+"'"};
+if(vErrors === null){
+vErrors = [err1];
+}
+else {
+vErrors.push(err1);
+}
+errors++;
+}
+if(data.app === undefined){
+const err2 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "app"},message:"must have required property '"+"app"+"'"};
+if(vErrors === null){
+vErrors = [err2];
+}
+else {
+vErrors.push(err2);
+}
+errors++;
+}
+if(data.port !== undefined){
+let data0 = data.port;
+if(!(typeof data0 == "number")){
+let dataType0 = typeof data0;
+let coerced0 = undefined;
+if(dataType0 == 'object' && Array.isArray(data0) && data0.length == 1){
+data0 = data0[0];
+dataType0 = typeof data0;
+if(typeof data0 == "number"){
+coerced0 = data0;
+}
+}
+if(!(coerced0 !== undefined)){
+if(dataType0 == "boolean" || data0 === null
+              || (dataType0 == "string" && data0 && data0 == +data0)){
+coerced0 = +data0;
+}
+else {
+const err3 = {instancePath:instancePath+"/port",schemaPath:"#/properties/port/type",keyword:"type",params:{type: "number"},message:"must be number"};
+if(vErrors === null){
+vErrors = [err3];
+}
+else {
+vErrors.push(err3);
+}
+errors++;
+}
+}
+if(coerced0 !== undefined){
+data0 = coerced0;
+if(data !== undefined){
+data["port"] = coerced0;
+}
+}
+}
+}
+if(data.dataFair !== undefined){
+let data1 = data.dataFair;
+if(data1 && typeof data1 == "object" && !Array.isArray(data1)){
+if(data1.url === undefined){
+const err4 = {instancePath:instancePath+"/dataFair",schemaPath:"#/properties/dataFair/required",keyword:"required",params:{missingProperty: "url"},message:"must have required property '"+"url"+"'"};
+if(vErrors === null){
+vErrors = [err4];
+}
+else {
+vErrors.push(err4);
+}
+errors++;
+}
+if(data1.owner === undefined){
+const err5 = {instancePath:instancePath+"/dataFair",schemaPath:"#/properties/dataFair/required",keyword:"required",params:{missingProperty: "owner"},message:"must have required property '"+"owner"+"'"};
+if(vErrors === null){
+vErrors = [err5];
+}
+else {
+vErrors.push(err5);
+}
+errors++;
+}
+if(data1.url !== undefined){
+let data2 = data1.url;
+if(typeof data2 !== "string"){
+let dataType1 = typeof data2;
+let coerced1 = undefined;
+if(dataType1 == 'object' && Array.isArray(data2) && data2.length == 1){
+data2 = data2[0];
+dataType1 = typeof data2;
+if(typeof data2 === "string"){
+coerced1 = data2;
+}
+}
+if(!(coerced1 !== undefined)){
+if(dataType1 == "number" || dataType1 == "boolean"){
+coerced1 = "" + data2;
+}
+else if(data2 === null){
+coerced1 = "";
+}
+else {
+const err6 = {instancePath:instancePath+"/dataFair/url",schemaPath:"#/properties/dataFair/properties/url/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err6];
+}
+else {
+vErrors.push(err6);
+}
+errors++;
+}
+}
+if(coerced1 !== undefined){
+data2 = coerced1;
+if(data1 !== undefined){
+data1["url"] = coerced1;
+}
+}
+}
+}
+if(data1.owner !== undefined){
+let data3 = data1.owner;
+if(data3 && typeof data3 == "object" && !Array.isArray(data3)){
+if(data3.type === undefined){
+const err7 = {instancePath:instancePath+"/dataFair/owner",schemaPath:"#/properties/dataFair/properties/owner/required",keyword:"required",params:{missingProperty: "type"},message:"must have required property '"+"type"+"'"};
+if(vErrors === null){
+vErrors = [err7];
+}
+else {
+vErrors.push(err7);
+}
+errors++;
+}
+if(data3.id === undefined){
+const err8 = {instancePath:instancePath+"/dataFair/owner",schemaPath:"#/properties/dataFair/properties/owner/required",keyword:"required",params:{missingProperty: "id"},message:"must have required property '"+"id"+"'"};
+if(vErrors === null){
+vErrors = [err8];
+}
+else {
+vErrors.push(err8);
+}
+errors++;
+}
+if(data3.type !== undefined){
+let data4 = data3.type;
+if(typeof data4 !== "string"){
+let dataType2 = typeof data4;
+let coerced2 = undefined;
+if(dataType2 == 'object' && Array.isArray(data4) && data4.length == 1){
+data4 = data4[0];
+dataType2 = typeof data4;
+if(typeof data4 === "string"){
+coerced2 = data4;
+}
+}
+if(!(coerced2 !== undefined)){
+if(dataType2 == "number" || dataType2 == "boolean"){
+coerced2 = "" + data4;
+}
+else if(data4 === null){
+coerced2 = "";
+}
+else {
+const err9 = {instancePath:instancePath+"/dataFair/owner/type",schemaPath:"#/properties/dataFair/properties/owner/properties/type/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err9];
+}
+else {
+vErrors.push(err9);
+}
+errors++;
+}
+}
+if(coerced2 !== undefined){
+data4 = coerced2;
+if(data3 !== undefined){
+data3["type"] = coerced2;
+}
+}
+}
+}
+if(data3.id !== undefined){
+let data5 = data3.id;
+if(typeof data5 !== "string"){
+let dataType3 = typeof data5;
+let coerced3 = undefined;
+if(dataType3 == 'object' && Array.isArray(data5) && data5.length == 1){
+data5 = data5[0];
+dataType3 = typeof data5;
+if(typeof data5 === "string"){
+coerced3 = data5;
+}
+}
+if(!(coerced3 !== undefined)){
+if(dataType3 == "number" || dataType3 == "boolean"){
+coerced3 = "" + data5;
+}
+else if(data5 === null){
+coerced3 = "";
+}
+else {
+const err10 = {instancePath:instancePath+"/dataFair/owner/id",schemaPath:"#/properties/dataFair/properties/owner/properties/id/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err10];
+}
+else {
+vErrors.push(err10);
+}
+errors++;
+}
+}
+if(coerced3 !== undefined){
+data5 = coerced3;
+if(data3 !== undefined){
+data3["id"] = coerced3;
+}
+}
+}
+}
+if(data3.department !== undefined){
+let data6 = data3.department;
+if(typeof data6 !== "string"){
+let dataType4 = typeof data6;
+let coerced4 = undefined;
+if(dataType4 == 'object' && Array.isArray(data6) && data6.length == 1){
+data6 = data6[0];
+dataType4 = typeof data6;
+if(typeof data6 === "string"){
+coerced4 = data6;
+}
+}
+if(!(coerced4 !== undefined)){
+if(dataType4 == "number" || dataType4 == "boolean"){
+coerced4 = "" + data6;
+}
+else if(data6 === null){
+coerced4 = "";
+}
+else {
+const err11 = {instancePath:instancePath+"/dataFair/owner/department",schemaPath:"#/properties/dataFair/properties/owner/properties/department/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err11];
+}
+else {
+vErrors.push(err11);
+}
+errors++;
+}
+}
+if(coerced4 !== undefined){
+data6 = coerced4;
+if(data3 !== undefined){
+data3["department"] = coerced4;
+}
+}
+}
+}
+}
+else {
+const err12 = {instancePath:instancePath+"/dataFair/owner",schemaPath:"#/properties/dataFair/properties/owner/type",keyword:"type",params:{type: "object"},message:"must be object"};
+if(vErrors === null){
+vErrors = [err12];
+}
+else {
+vErrors.push(err12);
+}
+errors++;
+}
+}
+if(data1.apiKey !== undefined){
+let data7 = data1.apiKey;
+if(typeof data7 !== "string"){
+let dataType5 = typeof data7;
+let coerced5 = undefined;
+if(dataType5 == 'object' && Array.isArray(data7) && data7.length == 1){
+data7 = data7[0];
+dataType5 = typeof data7;
+if(typeof data7 === "string"){
+coerced5 = data7;
+}
+}
+if(!(coerced5 !== undefined)){
+if(dataType5 == "number" || dataType5 == "boolean"){
+coerced5 = "" + data7;
+}
+else if(data7 === null){
+coerced5 = "";
+}
+else {
+const err13 = {instancePath:instancePath+"/dataFair/apiKey",schemaPath:"#/properties/dataFair/properties/apiKey/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err13];
+}
+else {
+vErrors.push(err13);
+}
+errors++;
+}
+}
+if(coerced5 !== undefined){
+data7 = coerced5;
+if(data1 !== undefined){
+data1["apiKey"] = coerced5;
+}
+}
+}
+}
+}
+else {
+const err14 = {instancePath:instancePath+"/dataFair",schemaPath:"#/properties/dataFair/type",keyword:"type",params:{type: "object"},message:"must be object"};
+if(vErrors === null){
+vErrors = [err14];
+}
+else {
+vErrors.push(err14);
+}
+errors++;
+}
+}
+if(data.app !== undefined){
+let data8 = data.app;
+if(data8 && typeof data8 == "object" && !Array.isArray(data8)){
+if(data8.url === undefined){
+const err15 = {instancePath:instancePath+"/app",schemaPath:"#/properties/app/required",keyword:"required",params:{missingProperty: "url"},message:"must have required property '"+"url"+"'"};
+if(vErrors === null){
+vErrors = [err15];
+}
+else {
+vErrors.push(err15);
+}
+errors++;
+}
+if(data8.proxyPaths === undefined){
+const err16 = {instancePath:instancePath+"/app",schemaPath:"#/properties/app/required",keyword:"required",params:{missingProperty: "proxyPaths"},message:"must have required property '"+"proxyPaths"+"'"};
+if(vErrors === null){
+vErrors = [err16];
+}
+else {
+vErrors.push(err16);
+}
+errors++;
+}
+if(data8.url !== undefined){
+let data9 = data8.url;
+if(typeof data9 !== "string"){
+let dataType6 = typeof data9;
+let coerced6 = undefined;
+if(dataType6 == 'object' && Array.isArray(data9) && data9.length == 1){
+data9 = data9[0];
+dataType6 = typeof data9;
+if(typeof data9 === "string"){
+coerced6 = data9;
+}
+}
+if(!(coerced6 !== undefined)){
+if(dataType6 == "number" || dataType6 == "boolean"){
+coerced6 = "" + data9;
+}
+else if(data9 === null){
+coerced6 = "";
+}
+else {
+const err17 = {instancePath:instancePath+"/app/url",schemaPath:"#/properties/app/properties/url/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err17];
+}
+else {
+vErrors.push(err17);
+}
+errors++;
+}
+}
+if(coerced6 !== undefined){
+data9 = coerced6;
+if(data8 !== undefined){
+data8["url"] = coerced6;
+}
+}
+}
+}
+if(data8.proxyPaths !== undefined){
+let data10 = data8.proxyPaths;
+if(!(Array.isArray(data10))){
+let dataType7 = typeof data10;
+let coerced7 = undefined;
+if(dataType7 == 'object' && Array.isArray(data10) && data10.length == 1){
+data10 = data10[0];
+dataType7 = typeof data10;
+if(Array.isArray(data10)){
+coerced7 = data10;
+}
+}
+if(!(coerced7 !== undefined)){
+if(dataType7 === "string" || dataType7 === "number"
+              || dataType7 === "boolean" || data10 === null){
+coerced7 = [data10];
+}
+else {
+const err18 = {instancePath:instancePath+"/app/proxyPaths",schemaPath:"#/properties/app/properties/proxyPaths/type",keyword:"type",params:{type: "array"},message:"must be array"};
+if(vErrors === null){
+vErrors = [err18];
+}
+else {
+vErrors.push(err18);
+}
+errors++;
+}
+}
+if(coerced7 !== undefined){
+data10 = coerced7;
+if(data8 !== undefined){
+data8["proxyPaths"] = coerced7;
+}
+}
+}
+if(Array.isArray(data10)){
+const len0 = data10.length;
+for(let i0=0; i0<len0; i0++){
+let data11 = data10[i0];
+if(typeof data11 !== "string"){
+let dataType8 = typeof data11;
+let coerced8 = undefined;
+if(dataType8 == 'object' && Array.isArray(data11) && data11.length == 1){
+data11 = data11[0];
+dataType8 = typeof data11;
+if(typeof data11 === "string"){
+coerced8 = data11;
+}
+}
+if(!(coerced8 !== undefined)){
+if(dataType8 == "number" || dataType8 == "boolean"){
+coerced8 = "" + data11;
+}
+else if(data11 === null){
+coerced8 = "";
+}
+else {
+const err19 = {instancePath:instancePath+"/app/proxyPaths/" + i0,schemaPath:"#/properties/app/properties/proxyPaths/items/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err19];
+}
+else {
+vErrors.push(err19);
+}
+errors++;
+}
+}
+if(coerced8 !== undefined){
+data11 = coerced8;
+if(data10 !== undefined){
+data10[i0] = coerced8;
+}
+}
+}
+}
+}
+}
+}
+else {
+const err20 = {instancePath:instancePath+"/app",schemaPath:"#/properties/app/type",keyword:"type",params:{type: "object"},message:"must be object"};
+if(vErrors === null){
+vErrors = [err20];
+}
+else {
+vErrors.push(err20);
+}
+errors++;
+}
+}
+if(data.serveUi !== undefined){
+let data12 = data.serveUi;
+if(typeof data12 !== "boolean"){
+let dataType9 = typeof data12;
+let coerced9 = undefined;
+if(dataType9 == 'object' && Array.isArray(data12) && data12.length == 1){
+data12 = data12[0];
+dataType9 = typeof data12;
+if(typeof data12 === "boolean"){
+coerced9 = data12;
+}
+}
+if(!(coerced9 !== undefined)){
+if(data12 === "false" || data12 === 0 || data12 === null){
+coerced9 = false;
+}
+else if(data12 === "true" || data12 === 1){
+coerced9 = true;
+}
+else {
+const err21 = {instancePath:instancePath+"/serveUi",schemaPath:"#/properties/serveUi/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};
+if(vErrors === null){
+vErrors = [err21];
+}
+else {
+vErrors.push(err21);
+}
+errors++;
+}
+}
+if(coerced9 !== undefined){
+data12 = coerced9;
+if(data !== undefined){
+data["serveUi"] = coerced9;
+}
+}
+}
+}
+}
+else {
+const err22 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
+if(vErrors === null){
+vErrors = [err22];
+}
+else {
+vErrors.push(err22);
+}
+errors++;
+}
+validate14.errors = vErrors;
+return errors === 0;
+}

package/config/type/index.d.ts

@@ -0,0 +1 @@
+export * from './.type/index.js'

package/config/type/index.js

@@ -0,0 +1 @@
+export * from './.type/index.js'

package/config/type/schema.js

@@ -0,0 +1,70 @@
+export default {
+  $id: 'https://github.com/data-fair/dev-server/config',
+  'x-exports': [
+    'types',
+    'validate'
+  ],
+  'x-ajv': {
+    coerceTypes: 'array'
+  },
+  'x-jstt': {
+    additionalProperties: false
+  },
+  type: 'object',
+  title: 'Dev server config',
+  required: [
+    'port',
+    'dataFair',
+    'app'
+  ],
+  properties: {
+    port: {
+      type: 'number'
+    },
+    dataFair: {
+      type: 'object',
+      required: ['url', 'owner'],
+      properties: {
+        url: {
+          type: 'string'
+        },
+        owner: {
+          type: 'object',
+          required: ['type', 'id'],
+          properties: {
+            type: {
+              type: 'string'
+            },
+            id: {
+              type: 'string'
+            },
+            department: {
+              type: 'string'
+            }
+          }
+        },
+        apiKey: {
+          type: 'string'
+        }
+      }
+    },
+    app: {
+      type: 'object',
+      required: ['url', 'proxyPaths'],
+      properties: {
+        url: {
+          type: 'string'
+        },
+        proxyPaths: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      }
+    },
+    serveUi: {
+      type: 'boolean'
+    },
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@data-fair/dev-server",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "A development server for optimal development experience of data-fair applications.",
   "main": "src/index.js",
   "bin": {
@@ -66,8 +66,10 @@
     "ws": "^8.18.3"
   },
   "files": [
-    "./config/dist/**/*",
+    "./config/**/*.js",
+    "./config/**/*.d.ts",
     "./ui/dist/**/*",
-    "./src/**/*"
+    "./src/**/*.js",
+    "./src/**/*.d.ts"
   ]
 }

package/src/app.d.ts

@@ -0,0 +1,2 @@
+export declare const run: () => Promise<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
+export declare const stop: () => Promise<void>;

package/src/config.d.ts

@@ -0,0 +1,4 @@
+import { type DevServerConfig } from '../config/type/index.js';
+export type { DevServerConfig } from '../config/type/index.ts';
+declare const _default: DevServerConfig;
+export default _default;

package/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/src/ui-config.d.ts

@@ -0,0 +1,13 @@
+export declare const uiConfig: {
+    dataFair: {
+        url: string;
+        owner: {
+            type: string;
+            id: string;
+            department?: string;
+        };
+        apiKey?: string;
+    };
+};
+export type UiConfig = typeof uiConfig;
+export default uiConfig;

package/src/app.ts

@@ -1,278 +0,0 @@
-// Express app for TaxMan own API and UI
-
-import config from './config.js'
-import uiConfig from './ui-config.js'
-import { WebSocket, WebSocketServer } from 'ws'
-import { createServer } from 'node:http'
-import express from 'express'
-import cors from 'cors'
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-import debugModule from 'debug'
-import { createProxyMiddleware, fixRequestBody } from 'http-proxy-middleware'
-import * as parse5 from 'parse5'
-import chalk from 'chalk'
-import { isElementNode, createTextNode, createElement } from '@parse5/tools'
-import escapeStringRegexp from 'escape-string-regexp'
-import eventPromise from '@data-fair/lib-utils/event-promise.js'
-import { createSpaMiddleware } from '@data-fair/lib-express/serve-spa.js'
-import { resolve } from 'node:path'
-
-const debug = debugModule('df-dev-server')
-
-const app = express()
-const server = createServer(app)
-
-// web socket server, used both by dev-server UI (opened on / path)
-// and by application (opened on /data-fair), in this case we transmit all messages to and from data-fair
-const wss = new WebSocketServer({ noServer: true })
-let devServerWS: WebSocket
-let dataFairWS: WebSocket
-server.on('upgrade', function upgrade (req, socket, head) {
-  wss.handleUpgrade(req, socket, head, (ws) => {
-    if (req.url === '/data-fair') {
-      if (dataFairWS) dataFairWS.terminate()
-      dataFairWS = ws
-      ws.on('message', (data: string) => {
-        if (dataFairOutputWS) {
-          const message = JSON.parse(data)
-          if (message.type === 'subscribe') message.apiKey = config.dataFair.apiKey
-          dataFairOutputWS.send(JSON.stringify(message))
-        }
-      })
-    } else {
-      if (devServerWS) devServerWS.terminate()
-      devServerWS = ws
-    }
-    wss.emit('connection', ws, req)
-  })
-})
-
-const dfWsUrl = config.dataFair.url.replace('http://', 'ws://').replace('https://', 'wss://') + '/'
-const dataFairOutputWS = new WebSocket(dfWsUrl)
-dataFairOutputWS.on('open', () => dataFairOutputWS.send('connect to external websocket server ' + dfWsUrl))
-dataFairOutputWS.on('message', (data) => { if (dataFairWS) dataFairWS.send(data.toString()) })
-dataFairOutputWS.on('error', (err) => console.error('failed to connect to external websocket server', dfWsUrl, err))
-
-app.use(cors())
-app.use(express.json())
-
-// very basic CRUD of config
-app.get('/config', (req, res, next) => {
-  const devConfig = existsSync('.dev-config.json') ? JSON.parse(readFileSync('.dev-config.json', 'utf8')) : {}
-  debug('read dev config', devConfig)
-  res.send(devConfig)
-})
-app.put('/config', (req, res, next) => {
-  debug('save dev config', req.body)
-  writeFileSync('.dev-config.json', JSON.stringify(req.body, null, 2))
-  res.send(req.body)
-})
-app.post('/config/error', (req, res) => {
-  console.log('Application sent an error', req.body)
-  if (devServerWS) devServerWS.send(JSON.stringify({ type: 'app-error', data: req.body }))
-  else console.error('no dev-server websocket open to send error to')
-  res.send()
-})
-
-// re-expose the application performing similar modifications to the body as data-fair
-const appUrl = new URL(config.app.url)
-const appPrefix = appUrl.pathname === '/' ? '' : appUrl.pathname
-app.use('/app', createProxyMiddleware({
-  target: appUrl.origin,
-  secure: false,
-  changeOrigin: true,
-  selfHandleResponse: true, // so that the onProxyRes takes care of sending the response
-  on: {
-    proxyReq (proxyReq, req, res) {
-      proxyReq.path = appPrefix + proxyReq.path
-      proxyReq.setHeader('Accept-Encoding', 'identity') // disable compression
-    },
-    proxyRes (proxyRes, req, res) {
-      const configuration = existsSync('.dev-config.json') ? JSON.parse(readFileSync('.dev-config.json', 'utf8')) : {}
-      // console.log('inject config', configuration)
-      const dataBuffers: Buffer[] = []
-      proxyRes.on('data', (data) => { dataBuffers.push(data) })
-      proxyRes.on('end', async () => {
-        try {
-          let output = Buffer.concat(dataBuffers).toString()
-          if (output.includes('%APPLICATION%')) {
-            const filledBody = output.replace(/%APPLICATION%/g, JSON.stringify({
-              id: 'dev-application',
-              title: 'Dev application',
-              configuration,
-              exposedUrl: `http://localhost:${config.port}/app`,
-              href: `http://localhost:${config.port}/config`,
-              apiUrl: `http://localhost:${config.port}/data-fair/api/v1`,
-              wsUrl: `ws://localhost:${config.port}/data-fair`,
-              owner: config.dataFair && config.dataFair.owner
-            }))
-            const document = parse5.parse(filledBody)
-            const html = document.childNodes.filter(isElementNode).find(c => c.tagName === 'html')
-            if (!html) throw new Error('HTML structure is broken, expect html, head and body elements')
-            const headNode = html.childNodes.filter(isElementNode).find(c => c.tagName === 'head')
-            const bodyNode = html.childNodes.filter(isElementNode).find(c => c.tagName === 'body')
-            if (!headNode || !bodyNode) throw new Error('HTML structure is broken, expect html, head and body elements')
-
-            // add a script to simulate instrumentation by capture service
-            // @ts-ignore
-            const query: Record<string, string> = req.query
-            if (query.thumbnail === 'true') {
-              const script = createElement('script', { type: 'text/javascript' })
-              script.childNodes.push(createTextNode(`
-              console.log('[capture] Simulate a screenshot capture context')
-              var triggerCalled = false
-              window.triggerCapture = function (animationSupported) {
-                triggerCalled = true
-                console.log('[capture] triggerCapture called')
-                if (animationSupported) {
-                  console.log('[capture] this application supports animated screenshots')
-                  var i = 0
-                  const interval = setInterval(function () {
-                    i++
-                    if (i === 1800) {
-                      console.error('[capture] stop after the maximum number of frames was attained')
-                      clearInterval(interval)
-                    }
-                    var stopped = window.animateCaptureFrame()
-                    if (stopped) {
-                      console.log('[capture] animation was stopped after ' + i + ' frames')
-                      clearInterval(interval)
-                    }
-                  }, 67)
-                  return true
-                } else {
-                  console.log('[capture] this application does not support animated screenshots')
-                }
-              }
-              setTimeout(function() {
-                if (!triggerCalled) {
-                  console.error('[capture] triggerCapture was not called after a 5s wait')
-                }
-              }, 5000)
-                              `))
-              headNode.childNodes.push(script)
-            }
-
-            const meta: Record<string, string> = {}
-            for (const node of headNode.childNodes.filter(isElementNode)) {
-              if (node.tagName === 'meta') {
-                const name = node.attrs.find(a => a.name === 'name')?.value
-                const content = node.attrs.find(a => a.name === 'content')?.value
-                if (name !== undefined && content !== undefined) meta[name] = content
-              }
-            }
-            if (meta['df:sync-state'] === 'true' || meta['df:overflow'] === 'true') {
-              bodyNode.childNodes.push(createElement('script', {
-                type: 'text/javascript',
-                src: 'https://cdn.jsdelivr.net/npm/@data-fair/frame@0.12/dist/v-iframe-compat/d-frame-content.min.js'
-              }))
-            }
-
-            output = parse5.serialize(document)
-
-            // proxyRes.headers['content-length'] = output.length
-            delete proxyRes.headers['content-length']
-            delete proxyRes.headers['last-modified']
-            delete proxyRes.headers['max-age']
-            delete proxyRes.headers.etag
-            proxyRes.headers['cache-control'] = 'no-cache'
-          }
-          res.writeHead(proxyRes.statusCode ?? 200, proxyRes.headers)
-          res.end(output)
-        } catch (err: any) {
-          console.error(err)
-          res.writeHead(500)
-          res.end(err.message)
-        }
-      })
-    }
-  }
-}))
-
-for (const proxyPath of config.app.proxyPaths) {
-  app.use(proxyPath, createProxyMiddleware({
-    target: appUrl.origin,
-    secure: false,
-    changeOrigin: true,
-    ws: true
-  }))
-}
-
-// re-expose a data-fair instance to access datasets, etc.
-const dfUrl = new URL(config.dataFair.url)
-app.use('/data-fair', createProxyMiddleware({
-  target: dfUrl.origin,
-  secure: false,
-  changeOrigin: true,
-  selfHandleResponse: true, // so that the onProxyRes takes care of sending the response
-  on: {
-    proxyReq (proxyReq, req, res) {
-      proxyReq.path = '/data-fair' + proxyReq.path
-
-      // no gzip so that we can process the content
-      proxyReq.setHeader('accept-encoding', 'identity')
-
-      // authentication through api key only
-      proxyReq.setHeader('cookie', '')
-      if (config.dataFair.apiKey) proxyReq.setHeader('x-apiKey', config.dataFair.apiKey)
-
-      // body was already parsed by body-parser and no longer available as a stream
-      fixRequestBody(proxyReq, req)
-    },
-    proxyRes (proxyRes, req, res) {
-      // console.log('DF RES', proxyRes)
-      if (proxyRes.headers['content-type'] && proxyRes.headers['content-type'].startsWith('application/json')) {
-        let body = ''
-        proxyRes.on('data', (data) => { body += data.toString() })
-        proxyRes.on('end', () => {
-          const output = body.replace(new RegExp(escapeStringRegexp(config.dataFair.url), 'g'), 'http://localhost:5888/data-fair')
-          // proxyRes.headers['content-length'] = output.length
-          delete proxyRes.headers['content-length']
-          res.writeHead(proxyRes.statusCode ?? 200, proxyRes.headers)
-          // make all references to data-fair url point to local proxy
-          res.end(output)
-        })
-      } else {
-        res.writeHead(proxyRes.statusCode ?? 200, proxyRes.headers)
-        proxyRes.pipe(res)
-      }
-    }
-  }
-}))
-
-// also re-expose the simple-directory instance matching data-fair
-app.use('/simple-directory', createProxyMiddleware({
-  target: dfUrl.origin,
-  secure: false,
-  changeOrigin: true,
-  on: {
-    proxyReq (proxyReq, req, res) {
-      proxyReq.path = '/simple-directory' + proxyReq.path
-    }
-  }
-}))
-
-if (config.serveUi) {
-  app.use(await createSpaMiddleware(resolve(import.meta.dirname, '../ui/dist'), uiConfig))
-} else {
-  app.use('/', createProxyMiddleware({
-    target: 'http://localhost:6220',
-    secure: false
-  }))
-}
-
-// Run app and return it in a promise
-export const run = async () => {
-  server.listen(config.port)
-  await eventPromise(server, 'listening')
-  console.log(chalk.bold.blue('\nDataFair dev server available on ') + chalk.underline.bold.blue(`http://localhost:${config.port}`))
-  return server
-}
-
-export const stop = async () => {
-  if (devServerWS) devServerWS.terminate()
-  if (dataFairWS) dataFairWS.terminate()
-  server.close()
-  await eventPromise(server, 'close')
-  await app.get('client').close()
-}

package/src/config.ts

@@ -1,12 +0,0 @@
-import { assertValid, type DevServerConfig } from '../config/type/index.js'
-import config from 'config'
-
-export type { DevServerConfig } from '../config/type/index.ts'
-
-// we reload the config instead of using the singleton from the config module for testing purposes
-// @ts-ignore
-const devServerConfig = process.env.NODE_ENV === 'test' ? config.util.loadFileConfigs(process.env.NODE_CONFIG_DIR, { skipConfigSources: true }) : config
-
-assertValid(devServerConfig, { lang: 'en', name: 'config', internal: true })
-
-export default devServerConfig as DevServerConfig

package/src/index.ts

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-
-import 'dotenv/config'
-import path from 'node:path'
-
-process.env.NODE_CONFIG_DIR = path.join(import.meta.dirname, '../config')
-const app = await import('./app.js')
-
-app.run().then(app => {
-  // nothing to do
-}, error => {
-  console.error('Failure in dev server process', error)
-  process.exit(-1)
-})
-
-process.on('SIGTERM', function onSigterm () {
-  console.info('Received SIGTERM signal, shutdown gracefully...')
-  app.stop().then(() => {
-    console.log('shutting down now')
-    process.exit()
-  }, err => {
-    console.error('Failure while stopping service', err)
-    process.exit(-1)
-  })
-})

package/src/ui-config.ts

@@ -1,6 +0,0 @@
-import config from './config.js'
-
-export const uiConfig = { dataFair: config.dataFair }
-
-export type UiConfig = typeof uiConfig
-export default uiConfig