{"version":3,"sources":["../../src/schema/compile-object.ts"],"sourcesContent":["import Definitions      from '../core/definitions';\r\nimport assertNever      from '../errors/asserts/asserts';\r\nimport SyntaxError      from '../errors/io-syntax-error';\r\nimport ErrorCodes       from '../errors/io-error-codes';\r\nimport ArrayNode        from '../parser/nodes/array';\r\nimport MemberNode       from '../parser/nodes/members';\r\nimport Node             from '../parser/nodes/nodes';\r\nimport ObjectNode       from '../parser/nodes/objects';\r\nimport TokenNode        from '../parser/nodes/tokens';\r\nimport TokenType        from '../parser/tokenizer/token-types';\r\nimport TypedefRegistry  from './typedef-registry';\r\nimport processSchema    from './processor';\r\nimport Schema           from './schema';\r\nimport Token            from '../parser/tokenizer/tokens';\r\nimport registerTypes    from './types';\r\nimport MemberDef        from './types/memberdef';\r\nimport createMemberDef  from './types/memberdef-factory';\r\nimport { canonicalizeAdditionalProps } from './utils/additional-props-canonicalizer';\r\nimport { normalizeKeyToken } from './utils/member-utils';\r\n\r\n// Register built-in types\r\n// registerTypes();\r\n\r\nexport default function compileObject(\r\n  name:string, node: Node, defs?:Definitions): Schema | TokenNode {\r\n  registerTypes();\r\n\r\n  // Check if the node is a string token and starts with $. If yes, then\r\n  // it is a schema variable. In this case, just return the node as it is\r\n  // to be processed later.\r\n  if (\r\n    node instanceof TokenNode &&\r\n    node.type === TokenType.STRING &&\r\n    typeof node.value === 'string' &&\r\n    node.value.startsWith('$')) {\r\n    return node;\r\n  }\r\n\r\n  if (node instanceof ObjectNode === false) {\r\n    throw new SyntaxError(ErrorCodes.invalidSchema, \"Schema must be an object.\", node);\r\n  }\r\n\r\n  const schema = new Schema(name)\r\n  parseObjectDef(node as ObjectNode, schema, \"\", defs);\r\n  return schema;\r\n}\r\n\r\nfunction parseObjectOrTypeDef(o: ObjectNode, path:string, defs?:Definitions) {\r\n  // When the object node is empty object, then the type definition is\r\n  // object without schema definition. Such objects can accept any object\r\n  // as value.\r\n  // For example:\r\n  // address: {},\r\n  if (o.children.length === 0) {\r\n    const schema = new Schema(path);\r\n    schema.open = true;\r\n    return {\r\n      type: 'object',\r\n      path,\r\n      schema\r\n    } as MemberDef;\r\n  }\r\n\r\n  // When the object node is type definition. The type deinition has first\r\n  // member as the type name\r\n  // For example:\r\n  // age: { number, min: 10, max: 20 }\r\n  const firstNode = o.children[0] as MemberNode;\r\n  if (!firstNode.key) {\r\n    if (firstNode.value instanceof TokenNode) {\r\n      const token = firstNode.value;\r\n      if (token.type === TokenType.STRING) {\r\n        const tokenValue = token.value as string;\r\n        // Built-in type shorthand: { string, min: ..., max: ... }\r\n        if (TypedefRegistry.isRegisteredType(tokenValue)) {\r\n          const memberDef = parseMemberDef(tokenValue, o, defs);\r\n          memberDef.path = path;\r\n          return memberDef;\r\n        }\r\n        // Schema variable shorthand: { $Person, ... }\r\n        if (tokenValue.startsWith('$')) {\r\n          return { type: 'object', schema: token, path } as MemberDef;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  // When the object node is a member type definition defined using the\r\n  // object definition syntax. It must hae a type property.\r\n  // For example:\r\n  // name: { min: 10, max: 20, type: string }\r\n  let type = '';\r\n  let typeNode = null;\r\n  for(let i=0; i<o.children.length; i++) {\r\n    const child = o.children[i];\r\n    if (child instanceof MemberNode && child.key && child.key.value === 'type') {\r\n      if (child.value instanceof TokenNode && child.value.type === TokenType.STRING) {\r\n        type = child.value.value as string;\r\n        typeNode = child.value;\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  // If type exists, and a valid type, then parse the member definition\r\n  // name: { minLength: 10, maxLength: 20, type: string }\r\n  if (type !== '') {\r\n    // Support type: $SchemaVar\r\n    if (typeof type === 'string' && type.startsWith('$')) {\r\n      return { type: 'object', schema: typeNode as any, path } as MemberDef;\r\n    }\r\n    if (TypedefRegistry.isRegisteredType(type)) {\r\n      const memberDef = parseMemberDef(type, o, defs);\r\n      memberDef.path = path;\r\n      return memberDef;\r\n    }\r\n\r\n    // If the type is not registered, then it is an invalid type\r\n    // name: { minLength: 10, maxLength: 20, type: xyz }\r\n    throw new SyntaxError(ErrorCodes.invalidType, `The specified value '${type}' is not a valid type.`, typeNode!);\r\n  }\r\n\r\n  // If the type is not defined, then consider it an object type with\r\n  // custom schema.\r\n  return {\r\n    type: 'object',\r\n    schema: parseObjectDef(o, new Schema(path), path, defs),\r\n    path,\r\n  } as MemberDef;\r\n}\r\n// field: {array, of:string, minLen:2}         # Array of strings with minimum length of 2\r\n// field: {array, of:string}                   # Array of strings\r\n// field: {of:string, type:array, minLen:2}    # Array of strings with minimum length of 2\r\n// field: {array, of:{ name: string, age: number }} # Array of objects\r\n// field: {array, of:[string]}                 # Array of arrays of strings\r\n// field: {array, of:{array, of:{}, minLen: 2 }} # Array of arrays of any type of objects with minimum length of 2\r\n//\r\n// Array Objects\r\n// field: { [], choices:[[a, b, c], [d, e, f]] }\r\n\r\n// Array MemberDefs\r\n// field: []                                   # Array of any type\r\n// field: [string]                             # Array of strings\r\n// field: [ [string] ]                         # Array of arrays of strings\r\n// field: [ { name: string, age: number } ]    # Array of objects\r\n// field: [ [ { name: string, age: number } ] ]# Array of arrays of objects\r\n// field: [ {type:string, len:6, pattern:r'[a-z0-9]+'} ]   # Array of strings with length of 6 and alphanumeric values\r\nfunction parseArrayOrTypeDef(a:ArrayNode, path:string, defs?:Definitions) :any {\r\n  // The length of the array child must be <= 1. If the length is > 1, then\r\n  // it is an invalid schema.\r\n  if (a.children.length > 1) {\r\n    throw new SyntaxError(ErrorCodes.invalidSchema, \"The array definition must have only one child.\", a.children[1] as Node);\r\n  }\r\n\r\n  // When the array node is empty array, then the type definition is\r\n  // array without schema definition. Such arrays can accept any type items\r\n  // in the array.\r\n  // For example:\r\n  // tags: []\r\n  if (a.children.length === 0) {\r\n    return createMemberDef({\r\n      type: 'array',\r\n      of: {\r\n        type: 'any',\r\n        path,\r\n        null: true,\r\n      },\r\n      path,\r\n    }, { allowNameless: true });\r\n  }\r\n\r\n  // When the array node has one child, then it is a type definition.\r\n  // For example:\r\n  // tags: [string], friends: [ { name: string, age: number } ]\r\n  //\r\n  const child = a.children[0];\r\n  if (child instanceof TokenNode) {\r\n    if (child.type === TokenType.STRING) {\r\n      const type = child.value as string;\r\n    // [string], [number], [boolean], [object], [array] etc.\r\n    if (TypedefRegistry.isRegisteredType(type)) {\r\n      return createMemberDef({\r\n        type: 'array',\r\n        of: {\r\n          type: child.value,\r\n          path,\r\n        },\r\n        path,\r\n      }, { allowNameless: true });\r\n    }\r\n\r\n    // If the type is a schema variable, then return the schema variable\r\n    // [$employee], [$address], [$person] etc.\r\n    else if (!!defs && type.startsWith('$')) {\r\n      return createMemberDef({\r\n        type: 'array',\r\n        of: {\r\n          type: 'object',\r\n          schema: child,\r\n          path,\r\n        },\r\n        path,\r\n      }, { allowNameless: true });\r\n    }\r\n  }\r\n\r\n    // If the type is not registered, then it is an invalid type\r\n    throw new SyntaxError(ErrorCodes.invalidType,`The specified value (${child.value}) is not a valid type`, child);\r\n  }\r\n\r\n  // If the child is an object node, then it is a member type definition\r\n  // For example:\r\n  // friends: [ { name: string, age: number } ]\r\n  if (child instanceof ObjectNode) {\r\n    return createMemberDef({\r\n      type: 'array',\r\n      of: parseObjectOrTypeDef(child, path, defs),\r\n      path,\r\n    }, { allowNameless: true });\r\n  }\r\n\r\n  // If the child is an array node, then it is an array type definition\r\n  // For example:\r\n  // friends: [ [string] ] or friends: [ [ { name: string, age: number } ] ]\r\n  if (child instanceof ArrayNode) {\r\n    return createMemberDef({\r\n      type: 'array',\r\n      of: parseArrayOrTypeDef(child, path, defs),\r\n      path,\r\n    }, { allowNameless: true });\r\n  }\r\n\r\n  // Throw an error if the child is not a string or object node\r\n  throw new SyntaxError(ErrorCodes.invalidSchema,\r\n    \"The array of type definition must be a string or object.\", child!);\r\n}\r\n\r\n// function parseArrayDef(o: ObjectNode, schema:Schema, path:string, defs?:Definitions): Schema {\r\n\r\n// }\r\n\r\nfunction parseObjectDef(o: ObjectNode, schema:Schema, path:string, defs?:Definitions): Schema {\r\n  // Note: empty-object and no-names cases are handled explicitly below.\r\n\r\n  for (let index = 0; index < o.children.length; index++) {\r\n    const child = o.children[index];\r\n    if (child === null) {\r\n      assertNever(\"Child value must not be null in schema definition.\");\r\n    }\r\n    const memberNode = child as MemberNode;\r\n    if (memberNode.value instanceof TokenNode && memberNode.value.type === TokenType.UNDEFINED) {\r\n      throw new SyntaxError(ErrorCodes.emptyMemberDef, \"The next member definition is empty.\", memberNode.value);\r\n    }\r\n\r\n    // Handle additional properties (dynamic fields)\r\n    if (memberNode.key && memberNode.key.value === '*') {\r\n      // Use getMemberDef for additional property to properly compile nested schemas\r\n      if (memberNode.value) {\r\n        // For ObjectNode values, use parseObjectOrTypeDef to properly compile the schema\r\n        if (memberNode.value instanceof ObjectNode) {\r\n          const additionalDef = parseObjectOrTypeDef(memberNode.value, '*', defs);\r\n          schema.defs['*'] = additionalDef as MemberDef;\r\n          schema.open = additionalDef as MemberDef;\r\n        }\r\n        // For ArrayNode values, use parseArrayOrTypeDef\r\n        else if (memberNode.value instanceof ArrayNode) {\r\n          const additionalDef = parseArrayOrTypeDef(memberNode.value, '*', defs);\r\n          schema.defs['*'] = additionalDef as MemberDef;\r\n          schema.open = additionalDef as MemberDef;\r\n        }\r\n        // For TokenNode (simple types or schema refs), use canonicalizer\r\n        else {\r\n          const additionalDef = canonicalizeAdditionalProps(memberNode.value, '*');\r\n          schema.defs['*'] = additionalDef;\r\n          schema.open = additionalDef;\r\n        }\r\n      } else {\r\n        schema.open = true;\r\n      }\r\n      if (index !== o.children.length - 1) {\r\n        throw new SyntaxError(ErrorCodes.invalidSchema, \"The * is only allowed at the last position.\", memberNode.value);\r\n      }\r\n      continue;\r\n    }\r\n\r\n    // Regular member\r\n    if (memberNode.key) {\r\n      const memberDef = getMemberDef(memberNode, path, defs);\r\n      addMemberDef(memberDef, schema, path);\r\n    } else {\r\n      // If the last index and the value is *, then this is an open schema\r\n      const open = memberNode.value instanceof TokenNode && memberNode.value.type === TokenType.STRING && memberNode.value.value === '*';\r\n      if (open) {\r\n        if (index !== o.children.length - 1) {\r\n          throw new SyntaxError(ErrorCodes.invalidSchema, \"The * is only allowed at the last position.\", memberNode.value);\r\n        }\r\n        schema.open = true;\r\n        continue;\r\n      }\r\n  // Normalize key token for keyless path to ensure Token | TokenNode(STRING)\r\n  const keyToken = normalizeKeyToken(memberNode.value);\r\n  const fieldInfo = parseName(keyToken);\r\n      // Always infer type as 'any' if not explicitly provided\r\n      const memberDef = createMemberDef({\r\n        ...fieldInfo,\r\n        type: 'any'\r\n      });\r\n      addMemberDef(memberDef, schema, path);\r\n    }\r\n  }\r\n\r\n  // If there are no regular members and schema.open wasn't already set\r\n  // to a MemberDef (from *: constraint), then set it to true (open with any type)\r\n  if (schema.names.length === 0 && schema.open === false) {\r\n    schema.open = true;\r\n  }\r\n\r\n  return schema;\r\n}\r\n\r\n/**\r\n * Dereferences variable references in an ObjectNode's members before schema validation.\r\n * This ensures that variables like @defaultQty are resolved to their actual values (1)\r\n * before type-specific validators (NumberDef, BooleanDef, etc.) process them.\r\n *\r\n * Two-stage dereferencing architecture:\r\n * 1. Schema compilation runtime: Resolves variables during MemberDef validation (here)\r\n * 2. Data processing runtime: Resolves variables via _resolveMemberDefVariables in processObject\r\n *\r\n * Modifies the ObjectNode in place for efficiency during schema compilation.\r\n */\r\nfunction dereferenceObjectNodeVariables(o: ObjectNode, defs?: Definitions): void {\r\n  if (!defs) return;\r\n\r\n  // Dereference variables in each member's value\r\n  for (const child of o.children) {\r\n    if (!(child instanceof MemberNode)) continue;\r\n\r\n    const value = child.value;\r\n\r\n    // Dereference variable in TokenNode values (e.g., default: @defaultQty)\r\n    if (value instanceof TokenNode &&\r\n        typeof value.value === 'string' &&\r\n        value.value.startsWith('@')) {\r\n      const resolved = defs.getV(value.value);\r\n      // getV returns the TokenNode stored for the variable (e.g., TokenNode with type NUMBER and value 1)\r\n      // Replace the variable reference TokenNode with the resolved value TokenNode\r\n      if (resolved instanceof TokenNode) {\r\n        (child as any).value = resolved;\r\n      } else {\r\n        // Fallback: if getV returned a raw value (shouldn't happen but be defensive)\r\n        (value as any).value = resolved;\r\n        // Update the token type based on the resolved value\r\n        if (typeof resolved === 'number') {\r\n          (value as any).type = TokenType.NUMBER;\r\n        } else if (typeof resolved === 'boolean') {\r\n          (value as any).type = TokenType.BOOLEAN;\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nfunction parseMemberDef(type:string, o: ObjectNode, defs?: Definitions) {\r\n  // Dereference variables in the ObjectNode before validation\r\n  dereferenceObjectNodeVariables(o, defs);\r\n\r\n  const typeDef = TypedefRegistry.get(type);\r\n  // Pass defs to processSchema so it can resolve variables during validation\r\n  const result = processSchema(o, typeDef.schema, defs);\r\n  return (result && typeof (result as any).toObject === 'function')\r\n    ? (result as any).toObject()\r\n    : result;\r\n}\r\n\r\nfunction addMemberDef(memberDef: MemberDef, schema: Schema, path:string) {\r\n  // Duplicate member detection (compile-time)\r\n  if (schema.defs[memberDef.name]) {\r\n    throw new SyntaxError(\r\n      ErrorCodes.duplicateMember,\r\n      `Member ${memberDef.name} is already defined in schema ${schema.name}.`,\r\n      (schema.defs[memberDef.name] as any)\r\n    );\r\n  }\r\n  memberDef.path = _(path, memberDef.name);\r\n  schema.names.push(memberDef.name);\r\n  schema.defs[memberDef.name] = memberDef;\r\n}\r\n\r\nconst parseName = (keyNode: Node): {\r\n  name: string,\r\n  optional: boolean,\r\n  null: boolean\r\n} => {\r\n  if (!keyNode) {\r\n    assertNever(\"Key node must not be null in schema definition.\")\r\n  }\r\n\r\n  if (!(keyNode instanceof Token)) {\r\n    throw new SyntaxError(ErrorCodes.invalidKey, \"The key must be a string.\", keyNode);\r\n  }\r\n\r\n  if (keyNode.type !== TokenType.STRING) {\r\n    throw new SyntaxError(ErrorCodes.invalidKey, \"The key must be a string.\", keyNode);\r\n  }\r\n\r\n  const key = keyNode.value as string;\r\n  const optionalExp = /\\?$/\r\n  const nullExp = /\\*$/\r\n  const optNullExp = /(\\?\\*)|(\\*\\?)$/\r\n\r\n  // Optional and null\r\n  if (key.match(optNullExp)) {\r\n    return {\r\n      name: key.substring(0, key.length - 2),\r\n      optional: true,\r\n      null: true\r\n    }\r\n  }\r\n\r\n  // null\r\n  if (key.match(nullExp)) {\r\n    return {\r\n      name: key.substring(0, key.length - 1),\r\n      optional: false,\r\n      null: true\r\n    }\r\n  }\r\n\r\n  // Optional\r\n  if (key.match(optionalExp) !== null) {\r\n    return {\r\n      name: key.substring(0, key.length - 1),\r\n      optional: true,\r\n      null: false\r\n    }\r\n  }\r\n  return { name: key, optional: false, null: false }\r\n}\r\n\r\n// moved to utils/member-utils.ts\r\n\r\nexport function getMemberDef(memberDef:MemberNode, path:string, defs?:Definitions): MemberDef {\r\n  const node = memberDef.value;\r\n\r\n  let fieldInfo = { name: \"\" }\r\n  if (memberDef.key) {\r\n  fieldInfo = parseName(normalizeKeyToken(memberDef.key));\r\n  }\r\n\r\n  // If the value token is a string, then ensure that it is a valid type\r\n  // For example:\r\n  // name: string, age: number\r\n  if (node instanceof TokenNode && node.type === TokenType.STRING) {\r\n    const type = node.value as string;\r\n\r\n    // If the type string starts with $, then it is a schema variable\r\n    if (type.startsWith('$')) {\r\n      return {\r\n        ...fieldInfo,\r\n        type: \"object\",\r\n        schema: node,\r\n      } as MemberDef;\r\n    }\r\n\r\n    if (TypedefRegistry.isRegisteredType(type) === false) {\r\n      throw new SyntaxError(ErrorCodes.invalidType,\r\n        `The type '${type}' is not supported.`, node);\r\n    }\r\n\r\n    return {\r\n      ...fieldInfo,\r\n      type,\r\n    } as MemberDef;\r\n  }\r\n\r\n  // If the value token is an object, then parse the object definition\r\n  if(node instanceof ObjectNode) {\r\n    const objectDef = parseObjectOrTypeDef(node, _(path, fieldInfo.name), defs);\r\n    return {\r\n      ...fieldInfo,\r\n      ...objectDef,\r\n    } as MemberDef;\r\n  }\r\n\r\n  // If the value token is an array, then parse the array definition\r\n  if(node instanceof ArrayNode) {\r\n    const arrayDef = parseArrayOrTypeDef(node, _(path, fieldInfo.name), defs);\r\n    return {\r\n      ...fieldInfo,\r\n      ...arrayDef,\r\n    } as MemberDef;\r\n  }\r\n\r\n  throw new SyntaxError(ErrorCodes.invalidType, `Found '${ node.toValue() }' but expecting a data type definition.`, node);\r\n}\r\n\r\n// concacts the path and key\r\nfunction _(path:string, key:string) {\r\n  if (path === \"\") {\r\n    return key;\r\n  }\r\n  return `${path}.${key}`;\r\n}\r\n"],"mappings":"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","names":["import_tokens","registerTypes","TokenNode","TokenType","ObjectNode","SyntaxError","ErrorCodes","Schema","TypedefRegistry","MemberNode","createMemberDef","ArrayNode","assertNever","processSchema","Token"]}