create-yss-spec 2.1.5 → 2.1.6

package/template/.trae/skills/drawio/scripts/adapters/graph-projection.js

@@ -1,335 +0,0 @@
-import {
-  AdapterContractError,
-  ERROR_CODES,
-  createEdgeIdentity,
-  normalizeIdentity,
-  serializeIdentity
-} from './identity.js'
-
-const MODES = new Set(['code', 'declared', 'live', 'drift'])
-const SAFE_NAME = /^[a-z][a-z0-9-]{0,63}$/
-const SENSITIVE_ATTRIBUTE_KEYS = new Set([
-  'apikey',
-  'body',
-  'authorization',
-  'bearertoken',
-  'clientsecret',
-  'credential',
-  'credentials',
-  'data',
-  'environment',
-  'password',
-  'privatekey',
-  'raw',
-  'secret',
-  'secrets',
-  'stringdata',
-  'token',
-  'accesstoken'
-])
-
-const TOP_LEVEL_KEYS = new Set(['version', 'source', 'nodes', 'edges', 'modules', 'diagnostics'])
-const SOURCE_KEYS = new Set(['adapter', 'domain', 'mode', 'locator'])
-const NODE_KEYS = new Set(['identity', 'label', 'semanticType', 'moduleIdentity', 'attributes', 'icon'])
-const EDGE_KEYS = new Set([
-  'identity',
-  'from',
-  'to',
-  'relation',
-  'discriminator',
-  'label',
-  'semanticType',
-  'attributes'
-])
-const MODULE_KEYS = new Set(['identity', 'label', 'attributes'])
-const DIAGNOSTIC_KEYS = new Set(['level', 'code', 'message', 'identity'])
-
-function projectionError(message, context = {}, cause) {
-  throw new AdapterContractError(ERROR_CODES.PROJECTION_INVALID, message, context, { cause })
-}
-
-function isRecord(value) {
-  return typeof value === 'object' && value != null && !Array.isArray(value)
-}
-
-function assertRecord(value, context) {
-  if (!isRecord(value)) projectionError(`${context} must be an object`)
-}
-
-function assertKnownKeys(value, allowed, context) {
-  const unknown = Object.keys(value).filter((key) => !allowed.has(key))
-  if (unknown.length > 0) projectionError(`${context} has unknown field "${unknown[0]}"`)
-}
-
-function requireSafeString(value, context, { pattern, maxLength = 512 } = {}) {
-  if (
-    typeof value !== 'string' ||
-    value.trim() === '' ||
-    value.length > maxLength ||
-    /[\u0000-\u001f\u007f]/.test(value)
-  ) {
-    projectionError(`${context} must be a non-empty safe string no longer than ${maxLength} characters`)
-  }
-  const normalized = value.trim()
-  if (pattern && !pattern.test(normalized)) projectionError(`${context} has an invalid format`)
-  return normalized
-}
-
-function normalizeLocator(value) {
-  const locator = requireSafeString(value, 'projection source.locator').replaceAll('\\', '/')
-  if (locator.startsWith('/') || /^[A-Za-z]:/.test(locator)) {
-    projectionError('projection source.locator must be relative')
-  }
-  const parts = []
-  for (const part of locator.split('/')) {
-    if (part === '' || part === '.') continue
-    if (part === '..') {
-      if (parts.length === 0) projectionError('projection source.locator must remain below its source root')
-      parts.pop()
-    } else {
-      parts.push(part)
-    }
-  }
-  if (parts.length === 0) projectionError('projection source.locator must identify a relative source')
-  return parts.join('/')
-}
-
-function normalizeSource(source) {
-  assertRecord(source, 'projection source')
-  assertKnownKeys(source, SOURCE_KEYS, 'projection source')
-  const mode = requireSafeString(source.mode, 'projection source.mode', { maxLength: 16 })
-  if (!MODES.has(mode)) projectionError(`projection source.mode must be one of ${[...MODES].join(', ')}`)
-  return {
-    adapter: requireSafeString(source.adapter, 'projection source.adapter', { pattern: SAFE_NAME, maxLength: 64 }),
-    domain: requireSafeString(source.domain, 'projection source.domain', { pattern: SAFE_NAME, maxLength: 64 }),
-    mode,
-    locator: normalizeLocator(source.locator)
-  }
-}
-
-function normalizeScalar(value, context) {
-  if (value === null || typeof value === 'boolean') return value
-  if (typeof value === 'number') {
-    if (!Number.isFinite(value)) projectionError(`${context} must be finite`)
-    return value
-  }
-  if (typeof value === 'string') {
-    if (value.length > 1000 || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)) {
-      projectionError(`${context} must be a safe string no longer than 1000 characters`)
-    }
-    return value
-  }
-  projectionError(`${context} must be a JSON scalar`)
-}
-
-function normalizeAttributeValue(value, context, depth = 0) {
-  if (Array.isArray(value)) {
-    if (value.length > 100) projectionError(`${context} has too many array values`)
-    return value.map((entry, index) => normalizeScalar(entry, `${context}[${index}]`))
-  }
-  if (isRecord(value) && depth === 0) {
-    if (Object.keys(value).length > 32) projectionError(`${context} has too many nested fields`)
-    return Object.fromEntries(
-      Object.keys(value)
-        .sort()
-        .map((key) => {
-          assertAttributeKeySafe(key, `${context}.${key}`)
-          return [key, normalizeAttributeValue(value[key], `${context}.${key}`, 1)]
-        })
-    )
-  }
-  return normalizeScalar(value, context)
-}
-
-function assertAttributeKeySafe(key, context) {
-  const normalized = String(key).replace(/[-_]/g, '').toLowerCase()
-  if (SENSITIVE_ATTRIBUTE_KEYS.has(normalized)) {
-    projectionError(`${context} is a sensitive attribute and cannot enter a projection`)
-  }
-  if (!/^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(key)) projectionError(`${context} has an invalid attribute name`)
-}
-
-function normalizeAttributes(attributes, kind, allowlist) {
-  if (attributes == null) return {}
-  assertRecord(attributes, `${kind} attributes`)
-  if (Object.keys(attributes).length > 32) projectionError(`${kind} attributes has too many fields`)
-  const allowed = new Set(allowlist?.[kind] || [])
-  return Object.fromEntries(
-    Object.keys(attributes)
-      .sort()
-      .map((key) => {
-        assertAttributeKeySafe(key, `${kind} attribute "${key}"`)
-        if (!allowed.has(key)) projectionError(`${kind} attribute "${key}" is not allowlisted`)
-        return [key, normalizeAttributeValue(attributes[key], `${kind} attribute "${key}"`)]
-      })
-  )
-}
-
-function safeIdentity(identity, context) {
-  try {
-    return normalizeIdentity(identity)
-  } catch (error) {
-    if (error?.code === ERROR_CODES.IDENTITY_INVALID) {
-      projectionError(`${context} is invalid: ${error.message}`, { identity }, error)
-    }
-    throw error
-  }
-}
-
-function normalizeNode(node, attributeAllowlist) {
-  assertRecord(node, 'projection node')
-  assertKnownKeys(node, NODE_KEYS, 'projection node')
-  const result = {
-    identity: safeIdentity(node.identity, 'projection node identity'),
-    label: requireSafeString(node.label, 'projection node label', { maxLength: 200 }),
-    attributes: normalizeAttributes(node.attributes, 'node', attributeAllowlist)
-  }
-  if (node.semanticType != null) {
-    result.semanticType = requireSafeString(node.semanticType, 'projection node semanticType', {
-      pattern: /^[a-z][a-z0-9_-]{0,63}$/,
-      maxLength: 64
-    })
-  }
-  if (node.icon != null) {
-    result.icon = requireSafeString(node.icon, 'projection node icon', {
-      pattern: /^[A-Za-z][A-Za-z0-9._-]*$/,
-      maxLength: 120
-    })
-  }
-  if (node.moduleIdentity != null) {
-    result.moduleIdentity = safeIdentity(node.moduleIdentity, 'projection node moduleIdentity')
-  }
-  return result
-}
-
-function normalizeModule(module, attributeAllowlist) {
-  assertRecord(module, 'projection module')
-  assertKnownKeys(module, MODULE_KEYS, 'projection module')
-  return {
-    identity: safeIdentity(module.identity, 'projection module identity'),
-    label: requireSafeString(module.label, 'projection module label', { maxLength: 200 }),
-    attributes: normalizeAttributes(module.attributes, 'module', attributeAllowlist)
-  }
-}
-
-function normalizeDiagnostic(diagnostic) {
-  assertRecord(diagnostic, 'projection diagnostic')
-  assertKnownKeys(diagnostic, DIAGNOSTIC_KEYS, 'projection diagnostic')
-  const level = requireSafeString(diagnostic.level, 'projection diagnostic.level', { maxLength: 16 })
-  if (!['info', 'warning'].includes(level)) projectionError('projection diagnostic.level must be info or warning')
-  const result = {
-    level,
-    code: requireSafeString(diagnostic.code, 'projection diagnostic.code', {
-      pattern: /^[A-Z][A-Z0-9_]{0,63}$/,
-      maxLength: 64
-    }),
-    message: requireSafeString(diagnostic.message, 'projection diagnostic.message', { maxLength: 500 })
-  }
-  if (diagnostic.identity != null) result.identity = safeIdentity(diagnostic.identity, 'projection diagnostic identity')
-  return result
-}
-
-function assertUniqueIdentities(items, kind) {
-  const seen = new Set()
-  for (const item of items) {
-    const key = serializeIdentity(item.identity)
-    if (seen.has(key)) projectionError(`duplicate ${kind} identity "${item.identity.scheme}:${item.identity.key}"`)
-    seen.add(key)
-  }
-  return seen
-}
-
-function normalizeEdges(edges, nodeIdentities, attributeAllowlist) {
-  const relationCounts = new Map()
-  const normalized = edges.map((edge) => {
-    assertRecord(edge, 'projection edge')
-    assertKnownKeys(edge, EDGE_KEYS, 'projection edge')
-    const from = safeIdentity(edge.from, 'projection edge.from')
-    const to = safeIdentity(edge.to, 'projection edge.to')
-    const relation = requireSafeString(edge.relation, 'projection edge.relation', {
-      pattern: /^[a-z][a-z0-9-]{0,63}$/,
-      maxLength: 64
-    })
-    const discriminator =
-      edge.discriminator == null
-        ? ''
-        : requireSafeString(edge.discriminator, 'projection edge.discriminator', { maxLength: 256 })
-    const baseKey = JSON.stringify([serializeIdentity(from), relation, serializeIdentity(to)])
-    relationCounts.set(baseKey, [...(relationCounts.get(baseKey) || []), discriminator])
-    const identity = createEdgeIdentity({ from, to, relation, discriminator })
-    if (
-      edge.identity != null &&
-      serializeIdentity(safeIdentity(edge.identity, 'projection edge identity')) !== serializeIdentity(identity)
-    ) {
-      projectionError('projection edge identity does not match its endpoints, relation, and discriminator')
-    }
-    const result = {
-      identity,
-      from,
-      to,
-      relation,
-      attributes: normalizeAttributes(edge.attributes, 'edge', attributeAllowlist)
-    }
-    if (discriminator) result.discriminator = discriminator
-    if (edge.label != null) result.label = requireSafeString(edge.label, 'projection edge label', { maxLength: 200 })
-    if (edge.semanticType != null) {
-      result.semanticType = requireSafeString(edge.semanticType, 'projection edge semanticType', {
-        pattern: /^[a-z][a-z0-9_-]{0,63}$/,
-        maxLength: 64
-      })
-    }
-    return result
-  })
-
-  for (const discriminators of relationCounts.values()) {
-    if (discriminators.length > 1 && discriminators.some((value) => value === '')) {
-      projectionError('parallel edges with the same endpoints and relation require a stable discriminator')
-    }
-  }
-
-  for (const edge of normalized) {
-    if (!nodeIdentities.has(serializeIdentity(edge.from)))
-      projectionError('projection edge references an unknown source')
-    if (!nodeIdentities.has(serializeIdentity(edge.to))) projectionError('projection edge references an unknown target')
-  }
-  assertUniqueIdentities(normalized, 'edge')
-  return normalized
-}
-
-export function finalizeGraphProjection(projection, { attributeAllowlist = {} } = {}) {
-  assertRecord(projection, 'projection')
-  assertKnownKeys(projection, TOP_LEVEL_KEYS, 'projection')
-  if (projection.version !== 1) projectionError('projection version must be 1')
-  for (const field of ['nodes', 'edges', 'modules', 'diagnostics']) {
-    if (!Array.isArray(projection[field])) projectionError(`projection ${field} must be an array`)
-  }
-  if (projection.nodes.length > 100) projectionError('projection has more than 100 nodes')
-  if (projection.edges.length > 200) projectionError('projection has more than 200 edges')
-  if (projection.modules.length > 20) projectionError('projection has more than 20 modules')
-
-  const source = normalizeSource(projection.source)
-  const nodes = projection.nodes.map((node) => normalizeNode(node, attributeAllowlist))
-  const modules = projection.modules.map((module) => normalizeModule(module, attributeAllowlist))
-  const nodeIdentities = assertUniqueIdentities(nodes, 'node')
-  const moduleIdentities = assertUniqueIdentities(modules, 'module')
-  for (const node of nodes) {
-    if (node.moduleIdentity && !moduleIdentities.has(serializeIdentity(node.moduleIdentity))) {
-      projectionError(`projection node "${node.label}" references an unknown module`)
-    }
-  }
-  const edges = normalizeEdges(projection.edges, nodeIdentities, attributeAllowlist)
-  const diagnostics = projection.diagnostics.map(normalizeDiagnostic)
-
-  const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0)
-  const byIdentity = (left, right) => compareText(serializeIdentity(left.identity), serializeIdentity(right.identity))
-  return {
-    version: 1,
-    source,
-    nodes: nodes.sort(byIdentity),
-    edges: edges.sort(byIdentity),
-    modules: modules.sort(byIdentity),
-    diagnostics: diagnostics.sort((left, right) =>
-      compareText(`${left.level}\0${left.code}\0${left.message}`, `${right.level}\0${right.code}\0${right.message}`)
-    )
-  }
-}

package/template/.trae/skills/drawio/scripts/adapters/graph-projection.test.js

@@ -1,141 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { ERROR_CODES, createComposeIdentity, createGroupIdentity } from './identity.js'
-import { finalizeGraphProjection } from './graph-projection.js'
-
-function projectionFixture() {
-  const moduleIdentity = createGroupIdentity({ domain: 'compose', key: 'shop' })
-  const api = createComposeIdentity({ project: 'shop', service: 'api' })
-  const db = createComposeIdentity({ project: 'shop', service: 'db' })
-  return {
-    version: 1,
-    source: { adapter: 'compose-config', domain: 'compose', mode: 'declared', locator: 'infra/compose.yml' },
-    nodes: [
-      {
-        identity: db,
-        label: 'Database',
-        semanticType: 'database',
-        moduleIdentity,
-        attributes: { image: 'postgres:16' }
-      },
-      {
-        identity: api,
-        label: 'API',
-        semanticType: 'service',
-        moduleIdentity,
-        attributes: { image: 'api:1' }
-      }
-    ],
-    edges: [{ from: api, to: db, relation: 'depends-on', attributes: { required: true } }],
-    modules: [{ identity: moduleIdentity, label: 'shop', attributes: { project: 'shop' } }],
-    diagnostics: [{ level: 'info', code: 'COMPOSE_PROJECT_EXPLICIT', message: 'Project identity is explicit.' }]
-  }
-}
-
-const attributeAllowlist = {
-  node: ['image'],
-  edge: ['required'],
-  module: ['project']
-}
-
-test('finalizeGraphProjection validates, enriches, and deterministically sorts a projection', () => {
-  const result = finalizeGraphProjection(projectionFixture(), { attributeAllowlist })
-
-  assert.equal(result.version, 1)
-  assert.deepEqual(
-    result.nodes.map((node) => node.label),
-    ['API', 'Database']
-  )
-  assert.equal(result.edges[0].identity.scheme, 'graph-edge')
-  assert.equal(result.modules[0].identity.scheme, 'compose-group')
-  assert.deepEqual(result.source, {
-    adapter: 'compose-config',
-    domain: 'compose',
-    mode: 'declared',
-    locator: 'infra/compose.yml'
-  })
-})
-
-test('projection schema declares the same required top-level contract', () => {
-  const schema = JSON.parse(
-    readFileSync(new URL('../../assets/schemas/graph-projection.schema.json', import.meta.url), 'utf8')
-  )
-  assert.equal(schema.properties.version.const, 1)
-  assert.deepEqual(schema.required, ['version', 'source', 'nodes', 'edges', 'modules', 'diagnostics'])
-  assert.equal(schema.additionalProperties, false)
-})
-
-test('projection validation rejects unknown versions, duplicate identities, and dangling edges', () => {
-  assert.throws(
-    () => finalizeGraphProjection({ ...projectionFixture(), version: 2 }, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /version/.test(error.message)
-  )
-
-  const duplicate = projectionFixture()
-  duplicate.nodes.push({ ...duplicate.nodes[0], label: 'Duplicate' })
-  assert.throws(
-    () => finalizeGraphProjection(duplicate, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /duplicate node identity/.test(error.message)
-  )
-
-  const dangling = projectionFixture()
-  dangling.edges[0].to = createComposeIdentity({ project: 'shop', service: 'missing' })
-  assert.throws(
-    () => finalizeGraphProjection(dangling, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /unknown target/.test(error.message)
-  )
-})
-
-test('projection validation rejects raw styles, absolute locators, and non-allowlisted or secret attributes', () => {
-  const styled = projectionFixture()
-  styled.nodes[0].style = 'fillColor=#fff;'
-  assert.throws(
-    () => finalizeGraphProjection(styled, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /unknown field "style"/.test(error.message)
-  )
-
-  const absolute = projectionFixture()
-  absolute.source.locator = 'C:\\private\\infra.yml'
-  assert.throws(
-    () => finalizeGraphProjection(absolute, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /relative/.test(error.message)
-  )
-
-  const unknown = projectionFixture()
-  unknown.nodes[0].attributes.region = 'us-east-1'
-  assert.throws(
-    () => finalizeGraphProjection(unknown, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /not allowlisted/.test(error.message)
-  )
-
-  const secret = projectionFixture()
-  secret.nodes[0].attributes.token = 'do-not-copy'
-  assert.throws(
-    () => finalizeGraphProjection(secret, { attributeAllowlist: { node: ['image', 'token'] } }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /sensitive attribute/.test(error.message)
-  )
-
-  const credentials = projectionFixture()
-  credentials.nodes[0].attributes.credentials = { username: 'admin' }
-  assert.throws(
-    () => finalizeGraphProjection(credentials, { attributeAllowlist: { node: ['image', 'credentials'] } }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /sensitive attribute/.test(error.message)
-  )
-})
-
-test('parallel edges require stable discriminators while a single relation does not', () => {
-  const duplicateEdge = projectionFixture()
-  duplicateEdge.edges.push({ ...duplicateEdge.edges[0] })
-  assert.throws(
-    () => finalizeGraphProjection(duplicateEdge, { attributeAllowlist }),
-    (error) => error.code === ERROR_CODES.PROJECTION_INVALID && /discriminator/.test(error.message)
-  )
-
-  duplicateEdge.edges[0].discriminator = 'declared:0'
-  duplicateEdge.edges[1].discriminator = 'declared:1'
-  const finalized = finalizeGraphProjection(duplicateEdge, { attributeAllowlist })
-  assert.equal(finalized.edges.length, 2)
-  assert.notEqual(finalized.edges[0].identity.key, finalized.edges[1].identity.key)
-})