@cloudcare/guance-front-tools 1.0.0

package/schemas/session-replay-schema.json

@@ -0,0 +1,33 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "session-replay-schema.json",
+    "title": "SessionReplay",
+    "type": "object",
+    "description": "Schema of all properties of Session Replay",
+    "allOf": [
+        {
+            "$ref": "session-replay/segment-schema.json"
+        },
+        {
+            "$ref": "session-replay/segment-metadata-schema.json"
+        },
+        {
+            "$ref": "session-replay/record-schema.json"
+        },
+        {
+            "$ref": "session-replay/full-snapshot-record-schema.json"
+        },
+        {
+            "$ref": "session-replay/incremental-snapshot-record-schema.json"
+        },
+        {
+            "$ref": "session-replay/incremental-data-schema.json"
+        },
+        {
+            "$ref": "session-replay/mutation-data-schema.json"
+        },
+        {
+            "$ref": "session-replay/mutation-payload-schema.json"
+        }
+    ]
+}

package/scripts/generate.mjs

@@ -0,0 +1,96 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { execSync } from 'child_process'
+import prettier from 'prettier'
+import { printLog, logAndExit } from './utils.mjs'
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json')
+
+const SCHEMAS_PATH = 'schemas'
+const PRETTIER_CONFIG = '.prettierrc.yml'
+
+const DEFINITIONS = [
+  {
+    source: 'session-replay-browser-schema.json',
+    name: 'browserSessionReplay',
+    options: { additionalProperties: false },
+  },
+  {
+    source: 'session-replay-mobile-schema.json',
+    name: 'mobileSessionReplay',
+    options: { additionalProperties: false },
+  },
+  { source: 'session-replay-schema.json', name: 'sessionReplay', options: { additionalProperties: false } },
+  {
+    source: 'dashboard-schema.json',
+    name: 'dashboardCharts',
+    options: {
+      additionalProperties: true,
+    },
+  },
+]
+
+const GENERATED_PATH = path.normalize(pkg.config['path:generated'])
+main().catch(logAndExit)
+
+async function main() {
+  fs.rmSync(GENERATED_PATH, { recursive: true, force: true })
+  fs.mkdirSync(GENERATED_PATH)
+
+  DEFINITIONS.forEach(async (definition) => {
+    const { source, name, options } = definition
+    await generateTypesFromSchema(path.join(GENERATED_PATH, `${name}.ts`), source, { options })
+  })
+}
+
+async function generateTypesFromSchema(typesPath, schema, { options = {} } = {}) {
+  const { compileFromFile } = await getJsonSchemaToTypescript()
+  const schemaPath = path.join(SCHEMAS_PATH, schema)
+  const prettierConfig = await prettier.resolveConfig(PRETTIER_CONFIG)
+  printLog(`Compiling ${schemaPath}...`)
+  const compiledTypes = await compileFromFile(schemaPath, {
+    cwd: SCHEMAS_PATH,
+    bannerComment: '/* eslint-disable */\n/**\n * DO NOT MODIFY IT BY HAND. Run `yarn generate` instead.\n*/',
+    style: prettierConfig,
+    ...options,
+  })
+  printLog(`Writing ${typesPath}...`)
+  fs.writeFileSync(typesPath, compiledTypes)
+  printLog('Generation done.')
+}
+
+async function getJsonSchemaToTypescript() {
+  if (!getJsonSchemaToTypescript.cache) {
+    getJsonSchemaToTypescript.cache = import('json-schema-to-typescript').catch((error) => {
+      if (error.code !== 'ERR_MODULE_NOT_FOUND') {
+        throw error
+      }
+      buildJsonSchemaToTypescript()
+      return import('json-schema-to-typescript')
+    })
+  }
+  return getJsonSchemaToTypescript.cache
+
+  function buildJsonSchemaToTypescript() {
+    printLog('json-schema-to-typescript not built. Building...')
+
+    execSync(
+      `
+        set -eu
+        cd ./node_modules/json-schema-to-typescript
+        rm -rf dist
+        # due to installation on node_modules, some of these steps can fail
+        # built version still behaves correctly though
+        set +e
+        npm i
+        npm run clean
+        npm run build:server
+        set -e
+      `,
+      {
+        stdio: 'inherit',
+      }
+    )
+  }
+}

package/scripts/utils.mjs

@@ -0,0 +1,16 @@
+const resetColor = '\x1b[0m'
+
+export function printLog(...params) {
+  const greenColor = '\x1b[32;1m'
+  console.log(greenColor, ...params, resetColor)
+}
+
+export function printError(...params) {
+  const redColor = '\x1b[31;1m'
+  console.log(redColor, ...params, resetColor)
+}
+
+export function logAndExit(error) {
+  printError('\nStacktrace:\n', error)
+  process.exit(1)
+}

package/scripts/validate.mjs

@@ -0,0 +1,144 @@
+import path from 'path'
+import Ajv from 'ajv'
+import { readdirSync, readFileSync } from 'fs'
+
+const SAMPLES_DIRECTORY = './samples'
+const SCHEMAS_DIRECTORY = './schemas'
+
+validateSchemasObjectsPropertiesCase()
+validateSchemasIds()
+validateSamples()
+
+if (process.exitCode !== 0 && process.exitCode !== undefined) {
+  console.log('❌ Some validation errors were found')
+}
+
+function validateSchemasObjectsPropertiesCase() {
+  // Some properties don't follow the convention. Ideally they should be fixed in the future.
+  const CASING_EXCEPTIONS = new Map([
+    [
+      `${SCHEMAS_DIRECTORY}/session-replay/common/_common-segment-metadata-schema.json`,
+      ['records_count', 'index_in_view', 'has_full_snapshot'],
+    ],
+    [`${SCHEMAS_DIRECTORY}/session-replay/common/focus-record-schema.json`, ['has_focus']],
+  ])
+
+  let displayConvention = false
+
+  forEachFile(SCHEMAS_DIRECTORY, (schemaPath) => {
+    if (!schemaPath.match(/\.json$/)) return
+    const schema = readJson(schemaPath)
+
+    const caseExceptions = CASING_EXCEPTIONS.get(schemaPath) || []
+
+    forEachObjectProperty(schema, (key) => {
+      const isCorrectCase = isCamelCase(key)
+      if (!isCorrectCase && !caseExceptions.includes(key)) {
+        console.log(`❌ Schema ${schemaPath} property ${key} is not $camelCase`)
+        displayConvention = true
+        process.exitCode = 1
+      }
+    })
+  })
+
+  if (displayConvention) {
+    console.log(
+      'ℹ️  RUM and telemetry schemas object properties should be snake_case, other schemas objects should be camelCase'
+    )
+  }
+}
+
+function validateSchemasIds() {
+  forEachFile(SCHEMAS_DIRECTORY, (schemaPath) => {
+    if (!schemaPath.match(/\.json$/)) return
+    const schema = readJson(schemaPath)
+
+    // We need to be careful about schema ids because they need to:
+    // * be unique, or else Ajv will throw
+    // * represent a path, as Ajv will use it to resolve $refs
+    // Here, we make sure that both requirements are respected.
+    const schemaId = computeSchemaIdFromSchemaPath(schemaPath)
+    if (schema.$id !== schemaId) {
+      console.log(`❌ Schema ${schemaPath} $id should be ${schemaId}`)
+      process.exitCode = 1
+    }
+  })
+}
+
+function validateSamples() {
+  const ajv = new Ajv()
+  forEachFile(SCHEMAS_DIRECTORY, (schemaPath) => {
+    if (!schemaPath.match(/\.json$/)) return
+    ajv.addSchema(readJson(schemaPath))
+  })
+  forEachFile(SAMPLES_DIRECTORY, (samplePath) => {
+    if (!samplePath.match(/\.json$/)) return
+    const schemaId = computeSchemaIdFromSamplePath(samplePath)
+    const valid = ajv.validate(schemaId, readJson(samplePath))
+    if (valid) {
+      console.log(`✅ ${samplePath}`)
+    } else {
+      console.log(`❌ ${samplePath} is not valid against ${schemaId}:`)
+      console.log(`   - ${ajv.errorsText(undefined, { separator: '\n   - ' })}`)
+      process.exitCode = 1
+    }
+  })
+}
+
+function computeSchemaIdFromSchemaPath(schemaPath) {
+  // Strip the schema directory from the provided path:
+  // "./schemas/session-replay/mobile/record-schema.json" -> "session-replay/mobile/record-schema.json"
+  return schemaPath.slice(SCHEMAS_DIRECTORY.length + 1)
+}
+
+function computeSchemaIdFromSamplePath(samplePath) {
+  // Keep only the directory path and strip the sample directory from the provided path:
+  // "./samples/session-replay/mobile/record/full-snapshot-record.json" -> "session-replay/mobile/record-schema.json"
+  return `${path.dirname(samplePath).slice(SAMPLES_DIRECTORY.length + 1)}-schema.json`
+}
+
+function forEachFile(directoryPath, callback) {
+  for (const entry of readdirSync(directoryPath, { withFileTypes: true })) {
+    const entryPath = `${directoryPath}/${entry.name}`
+    if (entry.isFile()) {
+      callback(entryPath)
+    } else {
+      forEachFile(entryPath, callback)
+    }
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, 'utf8'))
+}
+
+/**
+ * Iterates over each properties of objects specified in the provided JSON schema.
+ */
+function forEachObjectProperty(schema, callback) {
+  if (Array.isArray(schema)) {
+    // traverse arrays
+    for (const value of schema) {
+      forEachObjectProperty(value, callback)
+    }
+  } else if (typeof schema === 'object' && schema !== null) {
+    // traverse objects
+    for (const value of Object.values(schema)) {
+      forEachObjectProperty(value, callback)
+    }
+
+    if (schema.type === 'object' && schema.properties) {
+      for (const [key, value] of Object.entries(schema.properties)) {
+        callback(key, value)
+      }
+    }
+  }
+}
+
+function isSnakeCase(str) {
+  return /^[a-z0-9_]+$/.test(str)
+}
+
+function isCamelCase(str) {
+  return /^[a-z0-9][A-Za-z0-9]*$/.test(str)
+}

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "outDir": "lib/cjs"
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ES6",
+    "outDir": "lib/esm"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "es5",
+    "types": [],
+    "esModuleInterop": true,
+    "moduleResolution": "Node",
+    "outDir": "lib",
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["./lib/src/*.ts", "!./lib/script/*.ts"]
+}

package/tsconfig.script.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "esModuleInterop": true,
+    "moduleResolution": "node",
+    "module": "ES6",
+    "target": "ES6",
+    "outDir": "lib",
+    "declaration": false,
+    "resolveJsonModule": true,
+    "typeRoots": ["./node_modules/@types"]
+  },
+  "include": ["./lib/scripts/*.ts"],
+  "exclude": []
+}