tunli 0.0.19

package/src/config/ConfigAbstract.js

@@ -0,0 +1,318 @@
+import {writeFileSync} from "fs"
+import {dirname} from 'path'
+import {ensureDirectoryExists} from "#src/core/FS/utils";
+import {PropertyConfig} from "#src/config/PropertyConfig";
+
+const callerStack = new Map()
+
+/**
+ * Mark a value with a caller reference.
+ * @param {Object} callee - The caller object.
+ * @param {*} value - The value to be marked.
+ * @returns {*} - The marked value.
+ */
+const caller = (callee, value) => {
+  value = {value}
+  callerStack.set(value, callee)
+  return value
+}
+
+/**
+ * Check if a value is marked with a caller reference.
+ * @param {*} value - The value to check.
+ * @returns {boolean} - True if the value is marked, false otherwise.
+ */
+const isCaller = (value) => {
+  return callerStack.has(value)
+}
+
+/**
+ * Retrieve the caller reference for a value.
+ * @param {*} value - The value with the caller reference.
+ * @returns {Object} - The caller object.
+ */
+const callee = (value) => {
+  return callerStack.get(value)
+}
+
+export const VISIBILITY_PRIVATE = 0
+export const VISIBILITY_PUBLIC = 1
+
+/**
+ * Abstract class representing the basic configuration functionality.
+ * @implements {AppConfig}
+ */
+export class ConfigAbstract {
+  /**
+   * Configuration data.
+   * @type {Object}
+   * @private
+   */
+  #data = {}
+
+  /**
+   * Profile and system configuration data.
+   * @type {Object}
+   * @private
+   */
+  #profileData = {
+    profile: {}, system: {},
+  }
+
+  /**
+   * Path to the configuration file.
+   * @type {string}
+   * @private
+   */
+  #path
+
+  /**
+   * Fallback configuration instance.
+   * @type {ConfigAbstract}
+   * @private
+   */
+  #fallbackConfig
+
+  /**
+   * Defined properties.
+   * @type {Array<string>}
+   * @private
+   */
+  #definedProperties = []
+
+  /**
+   * Property configuration.
+   * @type {Object<string, PropertyConfig>}
+   * @private
+   */
+  #propertyConfig
+
+  /**
+   * Defined properties with inheritance.
+   * @type {Array<string>}
+   * @private
+   */
+  #definedWithInheritProperties
+
+  /**
+   * Active profile name.
+   * @type {string}
+   * @private
+   */
+  #activeProfile = 'default'
+
+  /**
+   * Create a ConfigAbstract instance.
+   * @param {Object} prefillData - Initial data to prefill the configuration.
+   * @param {string} path - The path to the configuration file.
+   * @param {ConfigAbstract} [fallbackConfig] - The fallback configuration.
+   */
+  constructor(prefillData = {}, path, fallbackConfig) {
+    this.#profileData = prefillData
+    this.#profileData.profile ??= {}
+    this.#profileData.system ??= {}
+    this.#path = path
+    this.#fallbackConfig = fallbackConfig
+  }
+
+  /**
+   * Get the fallback configuration.
+   * @return {ConfigAbstract}
+   */
+  get fallbackConfig() {
+    return this.#fallbackConfig
+  }
+
+  /**
+   * Get the profile data.
+   * @return {profileConfig}
+   */
+  get profileData() {
+    return this.#profileData
+  }
+
+  /**
+   * Get the configuration path.
+   * @return {string}
+   */
+  get configPath() {
+    return this.#path
+  }
+
+  get profile() {
+    return this.#activeProfile
+  }
+
+  /**
+   * Prepare the configuration by defining properties.
+   * @param {{[p: string]: PropertyConfig}} propertyConfig - The configuration properties.
+   */
+  prepare(propertyConfig = {}) {
+    this.#propertyConfig = propertyConfig
+
+    /**
+     * Define a property.
+     * @param {string} name - The name of the property.
+     * @param {PropertyConfig} propertyConfig - The configuration of the property.
+     */
+    const defineProperty = (name, propertyConfig) => {
+
+      let {writeable, visibility, type, defaultValue} = propertyConfig
+
+      this.#definedProperties.push(name)
+      const attributes = {
+        get: () => {
+          return this.#data[name] ?? this.#fallbackConfig?.[name] ?? defaultValue
+        }
+      }
+
+      if (writeable) {
+        /**
+         * Set the value of the property.
+         * This method checks if the value is marked with a caller reference
+         * and handles the writeable state accordingly. If the property is
+         * not writeable, an error is thrown. The value is also validated
+         * if a validation function is provided. Finally, the validated
+         * value is stored in the configuration data.
+         *
+         * @param {*} value - The value to set.
+         * @throws {Error} If the property is not writeable.
+         */
+        attributes.set = (value) => {
+          if (isCaller(value)) {
+            const writer = callee(value)
+            if (writeable && writeable !== true) {
+              writeable = writer instanceof writeable
+            }
+            value = value.value
+          }
+
+          if (!writeable) {
+            throw new Error(`property ${name} is not writeable`)
+          }
+
+          if (propertyConfig.validate) {
+            value = propertyConfig.validate(value)
+          }
+
+          this.#data[name] = value
+        }
+      }
+
+      Object.defineProperty(this, name, attributes)
+    }
+
+    for (const [name, setting] of Object.entries(propertyConfig)) {
+      defineProperty(name, setting)
+    }
+
+    this.#definedWithInheritProperties = Array.from(new Set([
+      ...this.#definedProperties,
+      ...(this.#fallbackConfig?.#definedWithInheritProperties ?? [])
+    ]))
+
+    for (const name of this.#fallbackConfig?.#definedWithInheritProperties ?? []) {
+      if (this.#definedProperties.includes(name)) {
+        continue
+      }
+
+      Object.defineProperty(this, name, {
+        get: () => {
+          return this.#fallbackConfig[name]
+        },
+        set: (value) => {
+          if (!isCaller(value)) {
+            value = caller(this, value)
+          }
+          this.#fallbackConfig[name] = value
+        }
+      })
+    }
+  }
+
+  /**
+   * Check if a property is public.
+   * @param {string} key - The property key.
+   * @returns {boolean} - True if the property is public, false otherwise.
+   */
+  isPublic(key) {
+    return this.#propertyConfig[key]?.visibility === VISIBILITY_PUBLIC
+  }
+
+  /**
+   * Save the configuration to the file system.
+   * @returns {ConfigAbstract} - The instance of the configuration.
+   */
+  save() {
+    ensureDirectoryExists(dirname(this.#path))
+    console.log(this.#path)
+    const isGlobal = this.constructor.name === 'GlobalConfig'
+    const isSystem = this.constructor.name === 'SystemConfig'
+
+    if (!isGlobal && !isSystem) {
+      delete this.#profileData.system
+    }
+
+    writeFileSync(this.#path, JSON.stringify(this.#profileData, null, 2) + "\n")
+    return this
+  }
+
+  /**
+   * Use the system configuration.
+   * @returns {ConfigAbstract} - The instance of the configuration.
+   */
+  useSystem() {
+    this.#data = this.#profileData.system
+    return this
+  }
+
+  /**
+   * Use a specific profile configuration.
+   * @param {string} profile - The profile name.
+   * @returns {ConfigAbstract} - The instance of the configuration.
+   */
+  use(profile) {
+    this.#profileData.profile[profile] ??= {}
+    this.#data = this.#profileData.profile[profile]
+    this.#activeProfile = profile
+    return this
+  }
+
+  /**
+   * Delete a property from the configuration.
+   * @param {string} key - The property key.
+   * @returns {ConfigAbstract} - The instance of the configuration.
+   */
+  del(key) {
+    this.#data[key] = undefined
+    return this
+  }
+
+  /**
+   * Copy the current profile to a new profile.
+   * @param {string} profile - The new profile name.
+   * @returns {ConfigAbstract} - The instance of the configuration.
+   */
+  copyCurrentProfileTo(profile) {
+    this.#profileData.profile[profile] = {...this.#data}
+    return this
+  }
+
+  /**
+   * Dump the configuration properties.
+   * @returns {Object} - The dumped properties.
+   */
+  dump() {
+    return Object.fromEntries(this.#definedProperties.map(x => {
+      let t = this[x]
+      if (Array.isArray(t)) {
+        if (t.length) {
+          t = t.join(', ')
+        } else {
+          t = undefined
+        }
+      }
+      return [x, t]
+    }))
+  }
+}

package/src/config/ConfigManager.js

@@ -0,0 +1,70 @@
+import {resolve} from "path";
+import {CONFIG_DIR_NAME, CONFIG_FILENAME, GLOBAL_CONFIG_DIR} from "#lib/defs";
+import {readJsonFile, searchDirInDirectoryTree} from "#src/core/FS/utils";
+import {existsSync} from "fs";
+
+import {GlobalConfig} from "#src/config/GlobalConfig";
+import {SystemConfig} from "#src/config/SystemConfig";
+import {LocalConfig} from "#src/config/LocalConfig";
+
+const LOCAL_CONFIG_DIR = resolve(process.cwd(), CONFIG_DIR_NAME)
+export const WORKDIR_CONFIG_DIR = resolve(process.cwd(), CONFIG_DIR_NAME)
+
+const searchConfigInDirectoryTree = () => {
+  return searchDirInDirectoryTree(CONFIG_DIR_NAME, undefined, [GLOBAL_CONFIG_DIR])
+}
+
+export class ConfigManager {
+
+  static loadLocalOnly(profile = 'default', searchInDirectoryTree = true) {
+    profile = normalizeProfileAlias(profile)
+
+    let configDirectory
+    if (searchInDirectoryTree) {
+      configDirectory = searchConfigInDirectoryTree() ?? LOCAL_CONFIG_DIR
+    } else {
+      configDirectory = LOCAL_CONFIG_DIR
+    }
+
+    const configFilePath = resolve(configDirectory, CONFIG_FILENAME);
+    const data = existsSync(configFilePath) ? readJsonFile(configFilePath) : {}
+
+    return new LocalConfig(data, configFilePath).use(profile)
+  }
+
+  static loadCombined(profile = 'default') {
+    profile = normalizeProfileAlias(profile)
+
+    const globalConfig = ConfigManager.loadGlobalOnly()
+    const localConfigDirectory = searchConfigInDirectoryTree() ?? LOCAL_CONFIG_DIR
+
+    const localConfigFilePath = resolve(localConfigDirectory, CONFIG_FILENAME);
+    const localExists = existsSync(localConfigFilePath)
+
+    if (localExists) {
+      return new LocalConfig(readJsonFile(localConfigFilePath), localConfigFilePath, globalConfig).use(profile)
+    }
+
+    return globalConfig.use(profile)
+  }
+
+  static loadSystem() {
+    const configFilePath = resolve(GLOBAL_CONFIG_DIR, CONFIG_FILENAME);
+    const data = existsSync(configFilePath) ? readJsonFile(configFilePath) : {}
+    return new SystemConfig(data)
+  }
+
+  static loadGlobalOnly(profile = 'default') {
+    profile = normalizeProfileAlias(profile)
+    const configFilePath = resolve(GLOBAL_CONFIG_DIR, CONFIG_FILENAME);
+    const data = existsSync(configFilePath) ? readJsonFile(configFilePath) : {}
+    return new GlobalConfig(data).use(profile)
+  }
+}
+
+const normalizeProfileAlias = (profileAlias) => {
+  if (typeof profileAlias === 'string' && profileAlias.startsWith('@')) {
+    profileAlias = profileAlias.toString().substring(1)
+  }
+  return profileAlias.toLowerCase()
+}

package/src/config/GlobalConfig.js

@@ -0,0 +1,14 @@
+import {GLOBAL_CONFIG_DIR} from "#lib/defs";
+import {resolve} from "path";
+import {GlobalLocalShardConfigAbstract} from "#src/config/GlobalLocalShardConfigAbstract";
+import {SystemConfig} from "#src/config/SystemConfig";
+
+export class GlobalConfig extends GlobalLocalShardConfigAbstract {
+
+  constructor(data) {
+    const alias = 'default'
+    const configFilePath = resolve(GLOBAL_CONFIG_DIR, `${alias}.json`);
+
+    super({}, data, configFilePath, new SystemConfig(data));
+  }
+}

package/src/config/GlobalLocalShardConfigAbstract.js

@@ -0,0 +1,76 @@
+import {checkHost, checkIpV4Cidr, checkPort, checkUrl} from "#src/utils/checkFunctions";
+import {ConfigAbstract, VISIBILITY_PUBLIC} from "#src/config/ConfigAbstract";
+import {property} from "#src/config/PropertyConfig";
+import {ConfigManager} from "#src/config/ConfigManager";
+
+/**
+ * Abstract class for managing global and local shard configurations.
+ * Extends the ConfigAbstract class to include properties specific to network configuration.
+ */
+export class GlobalLocalShardConfigAbstract extends ConfigAbstract {
+
+  #config = {
+
+    allowCidr: property({
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: Array,
+      defaultValue: [],
+      validate(val) {
+        return val.map(checkIpV4Cidr)
+      }
+    }),
+    proxyURL: property({
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: String,
+      validate(val) {
+        if (!val) {
+          return
+        }
+        return checkUrl(val)
+      }
+    }),
+    denyCidr: property({
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: Array,
+      defaultValue: [],
+      validate(val) {
+        return val.map(checkIpV4Cidr)
+      }
+    }),
+    port: property({
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: Number,
+      defaultValue: 80,
+      validate(val) {
+        return checkPort(val)
+      }
+    }),
+    host: property({
+      visibility: VISIBILITY_PUBLIC,
+      writeable: true,
+      type: String,
+      defaultValue: '127.0.0.1',
+      validate(val) {
+        return checkHost(val)
+      }
+    }),
+  }
+
+  /**
+   * Create a GlobalLocalShardConfigAbstract.
+   * @param {Object} additionalConfig - Additional configuration properties to be merged with the default config.
+   * @param {Object} prefillData - Initial data to prefill the configuration.
+   * @param {string} path - The path to the configuration file.
+   * @param {ConfigAbstract} fallbackConfig - The fallback configuration to be used when specific data is not available.
+   */
+  constructor(additionalConfig = {}, prefillData = {}, path, fallbackConfig) {
+    fallbackConfig ??= ConfigManager.loadSystem()
+    super(prefillData, path, fallbackConfig)
+    this.prepare({...this.#config, ...additionalConfig})
+    this.use('default')
+  }
+}

package/src/config/LocalConfig.js

@@ -0,0 +1,7 @@
+import {GlobalLocalShardConfigAbstract} from "#src/config/GlobalLocalShardConfigAbstract";
+
+export class LocalConfig extends GlobalLocalShardConfigAbstract {
+  constructor(data, path, globalConfig) {
+    super({}, data, path, globalConfig);
+  }
+}

package/src/config/PropertyConfig.js

@@ -0,0 +1,122 @@
+/**
+ * @callback validationCallback
+ * @template T
+ * @param {T} value
+ * @throws Error
+ * @returns {T}
+ */
+
+/**
+ * Class representing the configuration of a property.
+ */
+export class PropertyConfig {
+  /**
+   * The raw configuration data.
+   * @type {Object}
+   */
+  #data
+
+  /**
+   * The visibility level of the property.
+   * @type {number}
+   */
+  #visibility
+
+  /**
+   * Indicates if the property is writeable.
+   * When true, the property can be written to.
+   * If an instance of ConfigAbstract, only that instance can change the value.
+   * @type {boolean|ConfigAbstract}
+   */
+  #writeable
+
+  /**
+   * The validation function for the property.
+   * @type {validationCallback}
+   */
+  #validate
+
+  /**
+   * Default value for the property.
+   * @type {any}
+   */
+  #defaultValue
+
+  /**
+   * The type of the property.
+   * @type {Object}
+   */
+  #type
+
+  /**
+   * Create a PropertyConfig.
+   * @param {Object} data - The configuration data for the property.
+   * @param {number} data.visibility - The visibility level of the property.
+   * @param {boolean|ConfigAbstract} data.writeable - Indicates if the property is writeable.
+   * @param {validationCallback} data.validate - The validation function for the property.
+   * @param {any} data.defaultValue - The default value of the property.
+   * @param {Object} data.type - The type of the property.
+   */
+  constructor(data) {
+    this.#data = data
+    this.#visibility = data.visibility
+    this.#writeable = data.writeable
+    this.#validate = data.validate
+    this.#defaultValue = data.defaultValue
+    this.#type = data.type
+  }
+
+  /**
+   * Get the visibility of the property.
+   * @returns {number} The visibility level of the property.
+   */
+  get visibility() {
+    return this.#visibility
+  }
+
+  /**
+   * Check if the property is writeable.
+   * @returns {boolean|ConfigAbstract} True if the property is writeable, false otherwise.
+   */
+  get writeable() {
+    return this.#writeable
+  }
+
+  /**
+   * Get the validation function for the property.
+   * @returns {validationCallback} The validation function.
+   */
+  get validate() {
+    return this.#validate
+  }
+
+  /**
+   * Get the default value of the property.
+   * @returns {*} The default value of the property.
+   */
+  get defaultValue() {
+    return this.#defaultValue
+  }
+
+  /**
+   * Get the type of the property.
+   * @returns {Object} The type of the property.
+   */
+  get type() {
+    return this.#type
+  }
+}
+
+/**
+ * Factory function to create a PropertyConfig instance.
+ * @param {Object} propertySetup - The setup configuration for the property.
+ * @param {boolean|ConfigAbstract} propertySetup.writeable - Indicates if the property is writeable.
+ * @param {Object} propertySetup.type - The type of the property.
+ * @param {function} [propertySetup.validate] - The validation function for the property.
+ * @param {number} propertySetup.visibility - The visibility level of the property.
+ * @param {any} [propertySetup.defaultValue] - The default value of the property.
+ * @returns {PropertyConfig} The instance of PropertyConfig.
+ */
+export const property = (propertySetup) => {
+  return new PropertyConfig(propertySetup)
+}

package/src/config/SystemConfig.js

@@ -0,0 +1,31 @@
+import {GLOBAL_CONFIG_DIR} from "#lib/defs";
+import {resolve} from "path";
+import {ConfigAbstract, VISIBILITY_PRIVATE} from "#src/config/ConfigAbstract";
+import {property} from "#src/config/PropertyConfig";
+
+
+/**
+ * Class representing the system configuration.
+ * Extends ConfigAbstract to provide specific configuration for system settings.
+ */
+export class SystemConfig extends ConfigAbstract {
+  /**
+   * Create a SystemConfig instance.
+   * @param {Object} data - Initial data to prefill the configuration.
+   */
+  constructor(data) {
+    const alias = 'default'
+    const configFilePath = resolve(GLOBAL_CONFIG_DIR, `${alias}.json`)
+
+    super(data, configFilePath)
+
+    this.prepare({
+      authToken: property({
+        visibility: VISIBILITY_PRIVATE,
+        writeable: SystemConfig,
+        type: String
+      })
+    })
+    this.useSystem()
+  }
+}

package/src/core/FS/utils.js

@@ -0,0 +1,60 @@
+import {existsSync, lstatSync, mkdirSync, readFileSync} from "fs";
+import {dirname, join, parse} from "path";
+import {fileURLToPath} from "url";
+
+export const ensureDirectoryExists = (directory) => {
+  if (!existsSync(directory)) {
+    mkdirSync(directory)
+  }
+}
+
+export const searchDirInDirectoryTree = (dirnameToSearch, dir = process.cwd(), excludeDirectories = []) => {
+
+  dir ??= process.cwd()
+
+  while (dir !== parse(dir).root) {
+    const configPath = join(dir, dirnameToSearch);
+
+    dir = dirname(dir);
+
+    if (excludeDirectories.includes(configPath)) {
+      continue
+    }
+
+    if (existsSync(configPath) && lstatSync(configPath).isDirectory()) {
+      return configPath
+    }
+  }
+
+  return null;
+}
+export const searchFileInDirectoryTree = (filenameToSearch, dir = process.cwd(), excludeDirectories = []) => {
+
+  dir ??= process.cwd()
+
+  while (dir !== parse(dir).root) {
+    const configPath = join(dir, filenameToSearch);
+    dir = dirname(dir);
+
+    if (excludeDirectories.includes(configPath)) {
+      continue
+    }
+
+    if (existsSync(configPath) && lstatSync(configPath).isFile()) {
+      return configPath
+    }
+  }
+
+  return null;
+}
+
+export const readJsonFile = (configFilePath) => {
+  return JSON.parse(readFileSync(configFilePath, 'utf8'))
+}
+
+export const dirnameFromMeta = (importMeta) => {
+  return dirname(filenameFromMeta(importMeta));
+}
+export const filenameFromMeta = (importMeta) => {
+  return fileURLToPath(importMeta.url);
+}