@powerduck/schema-designer 0.1.0

package/dist/react/parametersTable/libs/generateValue.js

@@ -0,0 +1,551 @@
+import { resolveParameterSchema } from '../../../chunk-MADPN2PJ.js';
+import { dereferenceLocalSchema } from '../../../chunk-KX3LFFOV.js';
+import { Faker, en } from '@faker-js/faker';
+import Ajv from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+
+var generateSync;
+var DEFAULT_OPTIONS = {
+  humanize: true,
+  useDefault: true,
+  seed: Date.now(),
+  maxArrayItems: 3,
+  maxDepth: 5,
+  strictSchemaValidation: true,
+  validationRetryCount: 5
+};
+var ajv = new Ajv({ allErrors: true, strict: false, addUsedSchema: false });
+addFormats(ajv);
+var validators = /* @__PURE__ */ new WeakMap();
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isReference(value) {
+  return isRecord(value) && typeof value.$ref === "string";
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function normalizeTypes(schema) {
+  const t = schema.type;
+  if (typeof t === "string") return [t];
+  if (Array.isArray(t))
+    return t.filter((x) => typeof x === "string");
+  return [];
+}
+function getSchemaFormat(schema) {
+  return typeof schema.format === "string" ? schema.format : void 0;
+}
+function getParameterName(context) {
+  return context.parameter.name.trim().toLowerCase();
+}
+function tokenizeParameterName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-./:[\]{}]+/g, " ").split(/\s+/).filter(Boolean).map((token) => token.toLowerCase());
+}
+function hasToken(tokens, candidates) {
+  return candidates.some((candidate) => tokens.includes(candidate));
+}
+function hasAnyToken(tokens, candidates) {
+  return candidates.some(
+    (candidate) => tokens.some((t) => t.includes(candidate))
+  );
+}
+function resolveEnumValue(schema, fakerInstance, humanize) {
+  if (schema.const !== void 0) return schema.const;
+  if (!Array.isArray(schema.enum) || schema.enum.length === 0) return void 0;
+  return humanize ? fakerInstance.helpers.arrayElement(schema.enum) : schema.enum[0];
+}
+function getStringBounds(schema) {
+  return {
+    min: isFiniteNumber(schema.minLength) ? Math.max(0, schema.minLength) : void 0,
+    max: isFiniteNumber(schema.maxLength) ? Math.max(0, schema.maxLength) : void 0
+  };
+}
+function constrainString(value, schema) {
+  const { min, max } = getStringBounds(schema);
+  let result = value;
+  if (max !== void 0 && result.length > max) result = result.slice(0, max);
+  if (min !== void 0 && result.length < min)
+    result = result.padEnd(min, "x");
+  return result;
+}
+function getNumberBounds(schema, integer) {
+  const fallbackMin = 1;
+  const fallbackMax = integer ? 100 : 100;
+  let min = isFiniteNumber(schema.minimum) ? schema.minimum : fallbackMin;
+  let max = isFiniteNumber(schema.maximum) ? schema.maximum : fallbackMax;
+  if (typeof schema.exclusiveMinimum === "number") {
+    min = integer ? Math.max(min, Math.floor(schema.exclusiveMinimum) + 1) : Math.max(min, schema.exclusiveMinimum + Number.EPSILON);
+  }
+  if (typeof schema.exclusiveMaximum === "number") {
+    max = integer ? Math.min(max, Math.ceil(schema.exclusiveMaximum) - 1) : Math.min(max, schema.exclusiveMaximum - Number.EPSILON);
+  }
+  if (max < min) max = min;
+  return { min, max };
+}
+function generateInteger(schema, fakerInstance) {
+  const { min, max } = getNumberBounds(schema, true);
+  const multipleOf = isFiniteNumber(schema.multipleOf) && schema.multipleOf > 0 ? schema.multipleOf : void 0;
+  if (multipleOf) {
+    const minMultiple = Math.ceil(min / multipleOf);
+    const maxMultiple = Math.floor(max / multipleOf);
+    if (maxMultiple >= minMultiple) {
+      return fakerInstance.number.int({ min: minMultiple, max: maxMultiple }) * multipleOf;
+    }
+  }
+  return fakerInstance.number.int({
+    min: Math.ceil(min),
+    max: Math.floor(max)
+  });
+}
+function generateNumber(schema, fakerInstance) {
+  const { min, max } = getNumberBounds(schema, false);
+  const multipleOf = isFiniteNumber(schema.multipleOf) && schema.multipleOf > 0 ? schema.multipleOf : void 0;
+  if (multipleOf) {
+    const minMultiple = Math.ceil(min / multipleOf);
+    const maxMultiple = Math.floor(max / multipleOf);
+    if (maxMultiple >= minMultiple) {
+      return fakerInstance.number.int({ min: minMultiple, max: maxMultiple }) * multipleOf;
+    }
+  }
+  return fakerInstance.number.float({ min, max, fractionDigits: 2 });
+}
+function generateDate(schema, fakerInstance) {
+  const date = fakerInstance.date.recent({ days: 30 });
+  return getSchemaFormat(schema) === "date" ? date.toISOString().slice(0, 10) : date.toISOString();
+}
+function generateTime(fakerInstance) {
+  return fakerInstance.date.recent({ days: 1 }).toISOString().slice(11, 19);
+}
+function generateStringByParameterName(schema, context, fakerInstance) {
+  const parameterName = getParameterName(context);
+  const tokens = tokenizeParameterName(parameterName);
+  const format = getSchemaFormat(schema);
+  switch (format) {
+    case "email":
+      return fakerInstance.internet.email();
+    case "uuid":
+      return fakerInstance.string.uuid();
+    case "uri":
+    case "uri-reference":
+      return fakerInstance.internet.url();
+    case "hostname":
+      return fakerInstance.internet.domainName();
+    case "ipv4":
+      return fakerInstance.internet.ip();
+    case "ipv6":
+      return fakerInstance.internet.ipv6();
+    case "date":
+    case "date-time":
+      return generateDate(schema, fakerInstance);
+    case "time":
+      return generateTime(fakerInstance);
+    case "password":
+      return fakerInstance.internet.password({ length: 14, memorable: false });
+  }
+  if (hasAnyToken(tokens, ["uuid", "guid"])) return fakerInstance.string.uuid();
+  if (hasToken(tokens, ["id", "identifier", "key"])) {
+    return `usr_${fakerInstance.string.alphanumeric({ length: 10, casing: "lower" })}`;
+  }
+  if (hasAnyToken(tokens, ["firstname", "givenname"]))
+    return fakerInstance.person.firstName();
+  if (hasAnyToken(tokens, ["lastname", "surname", "familyname"]))
+    return fakerInstance.person.lastName();
+  if (hasAnyToken(tokens, ["fullname", "displayname", "username"]))
+    return fakerInstance.person.fullName();
+  if (hasAnyToken(tokens, ["email", "mail"]))
+    return fakerInstance.internet.email();
+  if (hasAnyToken(tokens, ["phone", "mobile", "telephone"]))
+    return fakerInstance.phone.number();
+  if (hasAnyToken(tokens, ["url", "uri", "website", "homepage", "link"]))
+    return fakerInstance.internet.url();
+  if (hasAnyToken(tokens, ["country", "countrycode"])) {
+    return hasAnyToken(tokens, ["code"]) ? fakerInstance.location.countryCode() : fakerInstance.location.country();
+  }
+  if (hasAnyToken(tokens, ["city"])) return fakerInstance.location.city();
+  if (hasAnyToken(tokens, ["state", "province", "region"]))
+    return fakerInstance.location.state();
+  if (hasAnyToken(tokens, ["zip", "zipcode", "postalcode", "postcode"]))
+    return fakerInstance.location.zipCode();
+  if (hasAnyToken(tokens, ["street", "address"]))
+    return fakerInstance.location.streetAddress();
+  if (hasAnyToken(tokens, ["company", "organization", "organisation"]))
+    return fakerInstance.company.name();
+  if (hasAnyToken(tokens, ["job", "title", "position", "role"]))
+    return fakerInstance.person.jobTitle();
+  if (hasAnyToken(tokens, [
+    "token",
+    "access_token",
+    "accesstoken",
+    "refresh_token",
+    "refreshtoken"
+  ])) {
+    return fakerInstance.string.alphanumeric({ length: 32, casing: "mixed" });
+  }
+  if (hasAnyToken(tokens, ["api_key", "apikey", "secret", "secretkey"])) {
+    return fakerInstance.string.alphanumeric({ length: 32, casing: "mixed" });
+  }
+  if (hasAnyToken(tokens, ["search", "query", "keyword", "q"])) {
+    return fakerInstance.helpers.arrayElement([
+      "laptop",
+      "coffee",
+      "openapi",
+      "developer tools",
+      "wireless headphones",
+      "running shoes",
+      "travel backpack"
+    ]);
+  }
+  if (hasAnyToken(tokens, ["slug"])) {
+    return fakerInstance.helpers.slugify(fakerInstance.commerce.productName()).toLowerCase();
+  }
+  if (hasAnyToken(tokens, ["product", "productname", "item"]))
+    return fakerInstance.commerce.productName();
+  if (hasAnyToken(tokens, ["description", "summary"]))
+    return fakerInstance.commerce.productDescription();
+  if (hasAnyToken(tokens, ["price", "amount", "cost", "total", "balance"])) {
+    return fakerInstance.commerce.price({ min: 10, max: 500, dec: 2 });
+  }
+  if (hasAnyToken(tokens, [
+    "date",
+    "birthday",
+    "birthdate",
+    "createdat",
+    "updatedat",
+    "deletedat",
+    "timestamp"
+  ])) {
+    return generateDate(schema, fakerInstance);
+  }
+  if (hasAnyToken(tokens, ["message", "comment", "note", "text"])) {
+    return fakerInstance.lorem.sentence({ min: 5, max: 12 });
+  }
+  return void 0;
+}
+function tryValidateValue(value, schema) {
+  try {
+    let validate = validators.get(schema);
+    if (!validate) {
+      validate = ajv.compile(schema);
+      validators.set(schema, validate);
+      ajv.removeSchema(schema);
+    }
+    return Boolean(validate(value));
+  } catch {
+    return false;
+  }
+}
+function generateSafeFallback(schema, genCtx, fakerInstance) {
+  const types = normalizeTypes(schema);
+  const pickedType = types.length ? fakerInstance.helpers.arrayElement(types) : void 0;
+  switch (pickedType) {
+    case "string":
+      return fakerInstance.string.alpha({ length: 10, casing: "mixed" });
+    case "integer":
+      return 1;
+    case "number":
+      return 1.5;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    case "null":
+      return null;
+    default:
+      return `${genCtx.parameter.name || "value"}-example`;
+  }
+}
+function prepareSchemaForJsf(schema, options) {
+  const maps = /* @__PURE__ */ new Set([
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas"
+  ]);
+  const arrays = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+  const singles = /* @__PURE__ */ new Set([
+    "items",
+    "contains",
+    "additionalProperties",
+    "unevaluatedProperties",
+    "unevaluatedItems",
+    "not",
+    "if",
+    "then",
+    "else",
+    "propertyNames"
+  ]);
+  const visit = (value) => {
+    if (!isRecord(value)) return value;
+    const result = { ...value };
+    if (value.type === "array" || value.items !== void 0) {
+      if (isFiniteNumber(value.minItems) && value.minItems > options.maxArrayItems)
+        throw new RangeError(
+          "Array minimum exceeds the generation item budget."
+        );
+      result.maxItems = Math.min(
+        isFiniteNumber(value.maxItems) ? value.maxItems : options.maxArrayItems,
+        options.maxArrayItems
+      );
+    }
+    if (value.type === "string" || value.minLength !== void 0 || value.maxLength !== void 0) {
+      if (isFiniteNumber(value.minLength) && value.minLength > 16384)
+        throw new RangeError(
+          "String minimum exceeds the generation length budget."
+        );
+      result.maxLength = Math.min(
+        isFiniteNumber(value.maxLength) ? value.maxLength : 16384,
+        16384
+      );
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if (maps.has(key) && isRecord(item))
+        result[key] = Object.fromEntries(
+          Object.entries(item).map(([name, child]) => [name, visit(child)])
+        );
+      else if (arrays.has(key) && Array.isArray(item))
+        result[key] = item.map(visit);
+      else if (singles.has(key)) result[key] = visit(item);
+    }
+    return result;
+  };
+  return visit(schema);
+}
+function generateGenericSchemaValue(schema, genCtx, options, fakerInstance) {
+  const preparedSchema = prepareSchemaForJsf(schema, options);
+  try {
+    const raw = generateSync(
+      preparedSchema,
+      {
+        seed: options.seed,
+        maxDepth: options.maxDepth,
+        maxDefaultItems: options.maxArrayItems,
+        optionalsProbability: 0.35,
+        alwaysFakeOptionals: false,
+        fillProperties: true,
+        useDefaultValue: options.useDefault,
+        useExamplesValue: false,
+        extensions: { faker: fakerInstance },
+        failOnInvalidTypes: false
+      }
+    );
+    if (!options.strictSchemaValidation || tryValidateValue(raw, schema)) {
+      return raw;
+    }
+    for (let i = 0; i <= options.validationRetryCount; i++) {
+      const retryVal = generateSync(
+        preparedSchema,
+        {
+          seed: options.seed + i,
+          maxDepth: options.maxDepth,
+          maxDefaultItems: options.maxArrayItems,
+          optionalsProbability: 0.35,
+          alwaysFakeOptionals: false,
+          fillProperties: true,
+          useDefaultValue: options.useDefault,
+          useExamplesValue: false,
+          extensions: { faker: fakerInstance },
+          failOnInvalidTypes: false
+        }
+      );
+      if (tryValidateValue(retryVal, schema)) return retryVal;
+    }
+    return raw;
+  } catch {
+    return generateSafeFallback(schema, genCtx, fakerInstance);
+  }
+}
+function generateStringWithRetry(schema, context, fakerInstance, humanize, strict, retry) {
+  const enumVal = resolveEnumValue(schema, fakerInstance, humanize);
+  if (enumVal !== void 0) {
+    const candidate2 = constrainString(String(enumVal), schema);
+    if (!strict || tryValidateValue(candidate2, schema)) return candidate2;
+  }
+  const humanVal = generateStringByParameterName(
+    schema,
+    context,
+    fakerInstance
+  );
+  if (humanVal !== void 0) {
+    const candidate2 = constrainString(humanVal, schema);
+    if (!strict || tryValidateValue(candidate2, schema)) return candidate2;
+  }
+  if (schema.pattern && typeof schema.pattern === "string") {
+    try {
+      const jsfVal = generateSync(schema);
+      if (typeof jsfVal === "string") {
+        if (!strict || tryValidateValue(jsfVal, schema)) return jsfVal;
+      }
+    } catch {
+    }
+  }
+  const { min, max } = getStringBounds(schema);
+  if (min !== void 0 && min > 16384)
+    throw new RangeError(
+      "String minimum exceeds the generation length budget."
+    );
+  const length = fakerInstance.number.int({
+    min: min ?? Math.min(8, max ?? 8),
+    max: Math.min(max ?? Math.max(min ?? 8, 24), 16384)
+  });
+  const candidate = constrainString(
+    fakerInstance.string.alpha({ length, casing: "mixed" }),
+    schema
+  );
+  if (!strict || tryValidateValue(candidate, schema)) return candidate;
+  if (retry <= 0) return candidate;
+  return generateStringWithRetry(
+    schema,
+    context,
+    fakerInstance,
+    humanize,
+    strict,
+    retry - 1
+  );
+}
+function generateArrayValue(schema, genCtx, options, fakerInstance) {
+  if (genCtx.depth >= options.maxDepth) return [];
+  const minItems = isFiniteNumber(schema.minItems) ? Math.max(0, schema.minItems) : Math.min(
+    1,
+    isFiniteNumber(schema.maxItems) ? Math.max(0, schema.maxItems) : 1
+  );
+  if (minItems > options.maxArrayItems)
+    throw new RangeError("Array minimum exceeds the generation item budget.");
+  const maxItems = isFiniteNumber(schema.maxItems) ? Math.min(options.maxArrayItems, Math.max(minItems, schema.maxItems)) : options.maxArrayItems;
+  const count = fakerInstance.number.int({ min: minItems, max: maxItems });
+  if (!schema.items || isReference(schema.items)) return [];
+  return Array.from(
+    { length: count },
+    (_, index) => generateFromSchema(
+      schema.items === true ? {} : schema.items,
+      { ...genCtx, rowIndex: genCtx.rowIndex + index, depth: genCtx.depth + 1 },
+      options,
+      fakerInstance
+    )
+  );
+}
+function generateObjectValue(schema, genCtx, options, fakerInstance) {
+  if (genCtx.depth >= options.maxDepth) return {};
+  const generated = generateGenericSchemaValue(
+    schema,
+    genCtx,
+    options,
+    fakerInstance
+  );
+  return isRecord(generated) ? generated : {};
+}
+function generateFromSchema(schema, genCtx, options, fakerInstance) {
+  if (genCtx.depth >= options.maxDepth) {
+    return generateSafeFallback(schema, genCtx, fakerInstance);
+  }
+  const enumVal = resolveEnumValue(schema, fakerInstance, options.humanize);
+  if (enumVal !== void 0) {
+    if (!options.strictSchemaValidation || tryValidateValue(enumVal, schema)) {
+      return enumVal;
+    }
+  }
+  const types = normalizeTypes(schema);
+  const targetType = types.length ? fakerInstance.helpers.arrayElement(types) : void 0;
+  switch (targetType) {
+    case "string":
+      return generateStringWithRetry(
+        schema,
+        genCtx,
+        fakerInstance,
+        options.humanize,
+        options.strictSchemaValidation,
+        options.validationRetryCount
+      );
+    case "integer": {
+      for (let i = 0; i <= options.validationRetryCount; i++) {
+        const candidate = generateInteger(schema, fakerInstance);
+        if (!options.strictSchemaValidation || tryValidateValue(candidate, schema))
+          return candidate;
+      }
+      return generateInteger(schema, fakerInstance);
+    }
+    case "number": {
+      for (let i = 0; i <= options.validationRetryCount; i++) {
+        const candidate = generateNumber(schema, fakerInstance);
+        if (!options.strictSchemaValidation || tryValidateValue(candidate, schema))
+          return candidate;
+      }
+      return generateNumber(schema, fakerInstance);
+    }
+    case "boolean": {
+      for (let i = 0; i <= options.validationRetryCount; i++) {
+        const candidate = typeof enumVal === "boolean" ? enumVal : fakerInstance.datatype.boolean();
+        if (!options.strictSchemaValidation || tryValidateValue(candidate, schema)) {
+          return candidate;
+        }
+      }
+      return false;
+    }
+    case "array":
+      return generateArrayValue(schema, genCtx, options, fakerInstance);
+    case "object":
+      return generateObjectValue(schema, genCtx, options, fakerInstance);
+    case "null": {
+      const candidate = null;
+      if (!options.strictSchemaValidation || tryValidateValue(candidate, schema)) {
+        return candidate;
+      }
+      return generateSafeFallback(schema, genCtx, fakerInstance);
+    }
+    default:
+      return generateGenericSchemaValue(schema, genCtx, options, fakerInstance);
+  }
+}
+async function generateParameterValue(context, inputOptions) {
+  context.signal?.throwIfAborted();
+  generateSync ??= (await import('json-schema-faker')).generateSync;
+  const options = { ...DEFAULT_OPTIONS, ...inputOptions };
+  for (const [key, maximum] of [
+    ["maxArrayItems", 1e3],
+    ["maxDepth", 32],
+    ["validationRetryCount", 20]
+  ]) {
+    const value2 = options[key];
+    if (!Number.isInteger(value2) || value2 < (key === "validationRetryCount" ? 0 : 1) || value2 > maximum) {
+      throw new RangeError(`Invalid generator option: ${key}`);
+    }
+  }
+  const fakerInstance = options.fakerInstance ?? new Faker({ locale: en });
+  if (inputOptions?.seed !== void 0 && !inputOptions?.fakerInstance) {
+    fakerInstance.seed(options.seed);
+  }
+  context.signal?.throwIfAborted();
+  let rawSchema = resolveParameterSchema(context.parameter, context.document) ?? context.parameter.schema;
+  if (rawSchema === void 0)
+    return `${context.parameter.name || "parameter"}-value`;
+  const resolvedSchema = dereferenceLocalSchema(
+    rawSchema,
+    context.document ?? rawSchema
+  );
+  if (resolvedSchema === false)
+    throw new Error("No value satisfies a false schema.");
+  const derefedSchema = resolvedSchema === true ? {} : resolvedSchema;
+  const generationSchema = prepareSchemaForJsf(
+    derefedSchema,
+    options
+  );
+  const genCtx = { ...context, depth: 0 };
+  context.signal?.throwIfAborted();
+  const value = generateFromSchema(
+    generationSchema,
+    genCtx,
+    options,
+    fakerInstance
+  );
+  if (options.strictSchemaValidation && !tryValidateValue(value, derefedSchema)) {
+    throw new Error(
+      "Unable to generate a value satisfying this schema. Provide an example or a custom generator."
+    );
+  }
+  return value;
+}
+
+export { generateParameterValue };

package/dist/react/schemaTreeEditor/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+require('../../chunk-OBHJC3I2.cjs');
+var chunkQZADGAP3_cjs = require('../../chunk-QZADGAP3.cjs');
+require('../../chunk-4H3LXOL4.cjs');
+require('../../chunk-GTZH37JS.cjs');
+require('../../chunk-YWDKCX6N.cjs');
+
+
+
+Object.defineProperty(exports, "SCHEMA_TYPES", {
+  enumerable: true,
+  get: function () { return chunkQZADGAP3_cjs.SCHEMA_TYPES; }
+});
+Object.defineProperty(exports, "SchemaTreeEditor", {
+  enumerable: true,
+  get: function () { return chunkQZADGAP3_cjs.SchemaTreeEditor; }
+});