@likec4/generators 1.52.0 → 1.53.0

package/src/likec4/operators/deployment.ts

@@ -0,0 +1,263 @@
+import type { Fqn } from '@likec4/core/types'
+import { invariant, nameFromFqn, parentFqn, sortParentsFirst } from '@likec4/core/utils'
+import { isEmptyish, pipe, values } from 'remeda'
+
+import { schemas } from '../schemas'
+import {
+  type AnyOp,
+  type Ctx,
+  body,
+  foreach,
+  inlineText,
+  lines,
+  print,
+  printProperty,
+  property,
+  select,
+  spaceBetween,
+  when,
+  withctx,
+  zodOp,
+} from './base'
+import { fqnRef } from './expressions'
+import {
+  colorProperty,
+  descriptionProperty,
+  linksProperty,
+  metadataProperty,
+  styleProperties,
+  summaryProperty,
+  tagsProperty,
+  technologyProperty,
+} from './properties'
+
+// --- Tree building ---
+
+type NodeData = schemas.deployment.node.Data
+type InstanceData = schemas.deployment.instance.Data
+type ElementData = schemas.deployment.element.Data
+
+type TreeNodeData =
+  | NodeData & {
+    children: Array<TreeNodeData>
+  }
+  | InstanceData
+
+function buildTree(elements: ElementData[]): {
+  roots: readonly TreeNodeData[]
+  nodes: ReadonlyMap<Fqn, TreeNodeData>
+  exists: (fqn: Fqn) => boolean
+} {
+  const nodes = new Map<Fqn, TreeNodeData>()
+  const roots: TreeNodeData[] = []
+  const sorted = pipe(
+    elements,
+    sortParentsFirst,
+  )
+
+  for (const element of sorted) {
+    let node: TreeNodeData
+    if ('element' in element) {
+      node = element
+    } else {
+      node = {
+        ...element,
+        children: [],
+      }
+    }
+    nodes.set(element.id, node)
+
+    const parentId = parentFqn(element.id)
+    const parent = parentId ? nodes.get(parentId) : undefined
+
+    if (parent && 'children' in parent) {
+      parent.children.push(node)
+    } else {
+      roots.push(node)
+    }
+  }
+
+  return {
+    roots,
+    nodes,
+    exists: (fqn: Fqn) => nodes.has(fqn),
+  }
+}
+
+// --- Predicates ---
+
+function hasStyleProps(el: NodeData | InstanceData): boolean {
+  return !isEmptyish(el.style)
+}
+
+function hasElementProps(el: ElementData): boolean {
+  return !!(
+    el.description || el.summary || el.technology || el.notation
+    || (el.tags && el.tags.length > 0)
+    || (el.links && el.links.length > 0)
+    || !isEmptyish(el.metadata)
+    || hasStyleProps(el)
+  )
+}
+
+// --- Element ---
+
+const elementProperties = zodOp(schemas.deployment.element)(
+  lines(
+    tagsProperty(),
+    technologyProperty(),
+    summaryProperty(),
+    descriptionProperty(),
+    linksProperty(),
+    metadataProperty(),
+    select(
+      e => hasStyleProps(e) ? e.style : undefined,
+      body('style')(
+        styleProperties(),
+      ),
+    ),
+  ),
+)
+
+export const instance = zodOp(schemas.deployment.instance)(
+  spaceBetween(
+    when(
+      v => nameFromFqn(v.id) !== nameFromFqn(v.element),
+      print(v => nameFromFqn(v.id)),
+      print(' ='),
+    ),
+    print('instanceOf'),
+    printProperty('element'),
+    when(
+      v => !!v.title && v.title !== nameFromFqn(v.id),
+      property('title', inlineText()),
+    ),
+    when(
+      e => hasElementProps(e),
+      body(
+        elementProperties(),
+      ),
+    ),
+  ),
+)
+
+export function node() {
+  return function nodeOp<E extends TreeNodeData>(
+    { ctx, out }: Ctx<E>,
+  ): Ctx<E> {
+    const el = ctx
+
+    if ('element' in el) {
+      instance()({ ctx: el, out })
+      return { ctx, out }
+    }
+    invariant('children' in el, 'Node must have children property')
+    const needsBody = el.children.length > 0 || hasElementProps(el)
+
+    const name = nameFromFqn(el.id)
+
+    const inline: AnyOp[] = [
+      print(name),
+      print('='),
+      print(el.kind),
+    ]
+
+    if (el.title && el.title !== name) {
+      inline.push(inlineText(el.title))
+    }
+
+    if (needsBody) {
+      inline.push(
+        body(
+          lines(2)(
+            withctx(el, elementProperties()),
+            ...el.children.map(node => withctx(node, nodeOp)),
+          ),
+        ),
+      )
+    }
+
+    return spaceBetween(...inline)({ ctx, out })
+  }
+}
+
+// --- Relationship ---
+
+function hasRelationStyle(rel: schemas.deployment.relationship.Data): boolean {
+  return !!(
+    rel.color || rel.line || rel.head || rel.tail
+  )
+}
+
+function hasRelationProps(rel: schemas.deployment.relationship.Data): boolean {
+  return !!(
+    rel.description || rel.summary || rel.technology
+    || (rel.tags && rel.tags.length > 0)
+    || (rel.links && rel.links.length > 0)
+    || !isEmptyish(rel.metadata)
+    || hasRelationStyle(rel)
+    || rel.navigateTo
+  )
+}
+
+export const relationship = zodOp(schemas.deployment.relationship)(
+  spaceBetween(
+    property('source', fqnRef()),
+    print(rel => rel.kind ? `-[${rel.kind}]->` : '->'),
+    property('target', fqnRef()),
+    property(
+      'title',
+      inlineText(),
+    ),
+    when(
+      hasRelationProps,
+      body(
+        tagsProperty(),
+        technologyProperty(),
+        summaryProperty(),
+        descriptionProperty(),
+        property('navigateTo'),
+        linksProperty(),
+        metadataProperty(),
+        when(
+          hasRelationStyle,
+          body('style')(
+            colorProperty(),
+            property('line'),
+            property('head'),
+            property('tail'),
+          ),
+        ),
+      ),
+    ),
+  ),
+)
+
+// export const element = zodOp(schemas.model.element)(
+//   elementTree(),
+// )
+
+// --- Main ---
+
+export const deployment = zodOp(schemas.deployment.schema)(
+  body('deployment')(
+    lines(2)(
+      select(
+        d => buildTree(d.elements ? values(d.elements) : []).roots,
+        lines(2)(
+          foreach(
+            node(),
+          ),
+        ),
+      ),
+      select(
+        d => d.relations ? values(d.relations) : undefined,
+        lines(2)(
+          foreach(
+            relationship(),
+          ),
+        ),
+      ),
+    ),
+  ),
+)

package/src/likec4/operators/expressions.ts

@@ -0,0 +1,422 @@
+import { type PredicateSelector, nonexhaustive } from '@likec4/core'
+import { joinToNode } from 'langium/generate'
+import { map } from 'remeda'
+import * as schemas from '../schemas/expression'
+import {
+  type Output,
+  body,
+  executeOnFresh,
+  fresh,
+  indent,
+  lazy,
+  merge,
+  print,
+  property,
+  space,
+  spaceBetween,
+  withctx,
+  zodOp,
+} from './base'
+import {
+  descriptionProperty,
+  markdownProperty,
+  notationProperty,
+  notesProperty,
+  styleProperties,
+  titleProperty,
+} from './properties'
+
+function appendSelector(out: Output, selector: PredicateSelector | undefined) {
+  if (selector) {
+    switch (selector) {
+      case 'children':
+        out.append('.*')
+        break
+      case 'descendants':
+        out.append('.**')
+        break
+      case 'expanded':
+        out.append('._')
+        break
+      default:
+        nonexhaustive(selector)
+    }
+  }
+  return out
+}
+
+export const whereTagEqual = zodOp(schemas.whereTag)(function whereTagEqualOp({ ctx: { tag }, out }) {
+  if ('eq' in tag) {
+    return out.appendTemplate`tag is #${tag.eq}`
+  }
+  if ('neq' in tag) {
+    return out.appendTemplate`tag is not #${tag.neq}`
+  }
+  nonexhaustive(tag)
+})
+
+export const whereKindEqual = zodOp(schemas.whereKind)(function whereKindEqualOp({ ctx: { kind }, out }) {
+  if ('eq' in kind) {
+    return out.appendTemplate`kind is ${kind.eq}`
+  }
+  if ('neq' in kind) {
+    return out.appendTemplate`kind is not ${kind.neq}`
+  }
+  nonexhaustive(kind)
+})
+
+function quoteMetadataValue(v: string): string {
+  return v === 'true' || v === 'false' ? v : `"${v}"`
+}
+
+export const whereMetadataEqual = zodOp(schemas.whereMetadata)(
+  function whereMetadataEqualOp({ ctx: { metadata }, out }) {
+    const { key, value } = metadata
+    if (value === undefined) {
+      return out.appendTemplate`metadata.${key}`
+    }
+    if ('eq' in value) {
+      return out.append(`metadata.${key} is ${quoteMetadataValue(value.eq)}`)
+    }
+    if ('neq' in value) {
+      return out.append(`metadata.${key} is not ${quoteMetadataValue(value.neq)}`)
+    }
+    nonexhaustive(value)
+  },
+)
+
+export const whereNot = zodOp(schemas.whereNot)(
+  property(
+    'not',
+    spaceBetween(
+      print('not ('),
+      lazy(() => whereOperator()),
+      print(')'),
+    ),
+  ),
+)
+
+export const whereParticipant = zodOp(schemas.whereParticipant)(
+  function whereParticipantOp({ ctx: { participant, operator }, out }) {
+    out.append(participant, '.')
+    if ('tag' in operator) {
+      whereTagEqual()({ ctx: operator, out })
+      return
+    }
+    if ('kind' in operator) {
+      whereKindEqual()({ ctx: operator, out })
+      return
+    }
+    if ('metadata' in operator) {
+      whereMetadataEqual()({ ctx: operator, out })
+      return
+    }
+    nonexhaustive(operator)
+  },
+)
+
+export const whereAnd = zodOp(schemas.whereAnd)(function whereAndOp({ ctx: { and }, out }) {
+  const operands = map(and, operand => {
+    let { out } = executeOnFresh(operand, whereOperator())
+    const wrapWithBraces = 'or' in operand
+    if (wrapWithBraces) {
+      out = fresh().out.append('(', ...out.contents, ')')
+    }
+    return out
+  })
+  return out.append(
+    joinToNode(operands, {
+      appendNewLineIfNotEmpty: true,
+      skipNewLineAfterLastItem: true,
+      prefix(_element, index) {
+        return index > 0 ? 'and ' : undefined
+      },
+    }),
+  )
+})
+
+export const whereOr = zodOp(schemas.whereOr)(({ ctx: { or }, out }) => {
+  const operands = map(or, operand => {
+    let { out } = executeOnFresh(operand, whereOperator())
+    const wrapWithBraces = 'and' in operand
+    if (wrapWithBraces) {
+      out = fresh().out.append('(', ...out.contents, ')')
+    }
+    return out
+  })
+  return out.append(
+    joinToNode(operands, {
+      appendNewLineIfNotEmpty: true,
+      skipNewLineAfterLastItem: true,
+      prefix(_element, index) {
+        return index > 0 ? 'or ' : undefined
+      },
+    }),
+  )
+})
+
+export const whereOperator = zodOp(schemas.whereOperator)(({ ctx, exec }) => {
+  if ('and' in ctx) {
+    return exec(ctx, whereAnd())
+  }
+  if ('or' in ctx) {
+    return exec(ctx, whereOr())
+  }
+  if ('not' in ctx) {
+    return exec(ctx, whereNot())
+  }
+  if ('tag' in ctx) {
+    return exec(ctx, whereTagEqual())
+  }
+  if ('kind' in ctx) {
+    return exec(ctx, whereKindEqual())
+  }
+  if ('metadata' in ctx) {
+    return exec(ctx, whereMetadataEqual())
+  }
+  if ('participant' in ctx) {
+    return exec(ctx, whereParticipant())
+  }
+  nonexhaustive(ctx)
+})
+
+export const fqnRef = zodOp(schemas.fqnRef)(({ ctx, out }) => {
+  if ('model' in ctx) {
+    out.append(ctx.model)
+  } else {
+    out.append(ctx.deployment)
+    if (ctx.element) {
+      out.append('.', ctx.element)
+    }
+  }
+  return out
+})
+
+export const fqnExpr = zodOp(schemas.fqnExpr)(({ ctx, out, exec }) => {
+  if ('wildcard' in ctx) {
+    return out.append('*')
+  }
+  if ('elementKind' in ctx) {
+    return out
+      .append('element.kind')
+      .append(ctx.isEqual ? ' = ' : ' != ')
+      .append(ctx.elementKind)
+  }
+  if ('elementTag' in ctx) {
+    return out
+      .append('element.tag')
+      .append(ctx.isEqual ? ' = ' : ' != ')
+      .append(`#${ctx.elementTag}`)
+  }
+  if ('ref' in ctx) {
+    exec(ctx.ref, fqnRef())
+    appendSelector(out, ctx.selector)
+    return out
+  }
+  nonexhaustive(ctx)
+})
+
+export const fqnExprCustom = zodOp(schemas.fqnExprCustom)(({ ctx: { custom }, exec }) => {
+  exec(
+    custom.expr,
+    fqnExprOrWhere(),
+  )
+  const customOp = withctx(custom)(
+    body('with')(
+      titleProperty(),
+      descriptionProperty(),
+      notationProperty(),
+      notesProperty(),
+      property('navigateTo'),
+      styleProperties(),
+    ),
+  )
+  if ('where' in custom.expr) {
+    return exec(
+      {},
+      indent(
+        customOp,
+      ),
+    )
+  }
+  return exec(
+    {},
+    space(),
+    customOp,
+  )
+})
+
+export const fqnExprOrWhere = zodOp(schemas.fqnExprOrWhere)(({ ctx, exec }) => {
+  if ('where' in ctx) {
+    exec(ctx.where.expr, fqnExpr())
+    exec(
+      ctx.where.condition,
+      indent(
+        print('where'),
+        indent(
+          whereOperator(),
+        ),
+      ),
+    )
+    return
+  }
+  exec(ctx, fqnExpr())
+})
+
+export const fqnExprAny = zodOp(schemas.fqnExprAny)(({ ctx, out }) => {
+  if ('custom' in ctx) {
+    return fqnExprCustom()({ ctx, out })
+  }
+  return fqnExprOrWhere()({ ctx, out })
+})
+
+// ──────────────────────────────────────────────
+// RelationExpr operators (expression.ts types)
+// ──────────────────────────────────────────────
+
+export const directRelationExpr = zodOp(schemas.directRelationExpr)(
+  merge(
+    property(
+      'source',
+      fqnExpr(),
+    ),
+    print(v => v.isBidirectional ? ' <-> ' : ' -> '),
+    property(
+      'target',
+      fqnExpr(),
+    ),
+  ),
+)
+
+export const incomingRelationExpr = zodOp(schemas.incomingRelationExpr)(
+  merge(
+    print('-> '),
+    property(
+      'incoming',
+      fqnExpr(),
+    ),
+  ),
+)
+
+export const outgoingRelationExpr = zodOp(schemas.outgoingRelationExpr)(
+  merge(
+    property(
+      'outgoing',
+      fqnExpr(),
+    ),
+    print(' ->'),
+  ),
+)
+
+export const inOutRelationExpr = zodOp(schemas.inoutRelationExpr)(
+  merge(
+    print('-> '),
+    property(
+      'inout',
+      fqnExpr(),
+    ),
+    print(' ->'),
+  ),
+)
+
+export const relationExpr = zodOp(schemas.relationExpr)(({ ctx, exec }) => {
+  if ('source' in ctx) {
+    return exec(ctx, directRelationExpr())
+  }
+  if ('incoming' in ctx) {
+    return exec(ctx, incomingRelationExpr())
+  }
+  if ('outgoing' in ctx) {
+    return exec(ctx, outgoingRelationExpr())
+  }
+  if ('inout' in ctx) {
+    return exec(ctx, inOutRelationExpr())
+  }
+  nonexhaustive(ctx)
+})
+
+export const relationExprOrWhere = zodOp(schemas.relationExprOrWhere)(({ ctx, out }) => {
+  if ('where' in ctx) {
+    return merge(
+      withctx(ctx.where.expr)(
+        relationExpr(),
+      ),
+      indent(
+        print('where'),
+        indent(
+          withctx(ctx.where.condition)(
+            whereOperator(),
+          ),
+        ),
+      ),
+    )({ ctx, out })
+  }
+  return relationExpr()({ ctx, out })
+})
+
+export const relationExprCustom = zodOp(schemas.relationExprCustom)(({ ctx: { customRelation }, exec }) => {
+  exec(
+    customRelation.expr,
+    relationExprOrWhere(),
+  )
+
+  const customOp = withctx(customRelation)(
+    body('with')(
+      titleProperty(),
+      descriptionProperty(),
+      notationProperty(),
+      markdownProperty('notes'),
+      property('navigateTo'),
+      styleProperties(),
+      property('head'),
+      property('tail'),
+      property('line'),
+    ),
+  )
+  const hasWhere = 'where' in customRelation.expr
+
+  if (hasWhere) {
+    exec({}, indent(customOp))
+  } else {
+    exec({}, space(), customOp)
+  }
+})
+
+export const relationExprAny = zodOp(schemas.relationExprAny)(({ ctx, exec }) => {
+  if ('customRelation' in ctx) {
+    return exec(ctx, relationExprCustom())
+  }
+  return exec(ctx, relationExprOrWhere())
+})
+
+// ──────────────────────────────────────────────
+// Expression dispatcher (expression.ts types)
+// ──────────────────────────────────────────────
+
+export const expression = zodOp(schemas.expression)(({ ctx, exec }) => {
+  if ('custom' in ctx) {
+    return exec(ctx, fqnExprCustom())
+  }
+  if ('customRelation' in ctx) {
+    return exec(ctx, relationExprCustom())
+  }
+  if ('wildcard' in ctx || 'ref' in ctx || 'elementKind' in ctx || 'elementTag' in ctx) {
+    return exec(ctx, fqnExpr())
+  }
+  if ('source' in ctx || 'incoming' in ctx || 'outgoing' in ctx || 'inout' in ctx) {
+    return exec(ctx, relationExpr())
+  }
+  if ('where' in ctx) {
+    const { expr, condition } = ctx.where
+    if ('source' in expr || 'incoming' in expr || 'outgoing' in expr || 'inout' in expr) {
+      return exec({
+        where: {
+          expr,
+          condition,
+        },
+      }, relationExprOrWhere())
+    }
+    return exec({ where: { expr, condition } }, fqnExprOrWhere())
+  }
+  nonexhaustive(ctx)
+})

package/src/likec4/operators/index.ts

@@ -0,0 +1,13 @@
+export * as base from './base'
+export * as deployments from './deployment'
+export { deployment } from './deployment'
+export * as expr from './expressions'
+export { expression } from './expressions'
+export { likec4data } from './likec4data'
+export * as models from './model'
+export { model } from './model'
+export * as props from './properties'
+export * as specifications from './specification'
+export { specification } from './specification'
+export { deploymentView, dynamicView, elementView } from './views'
+export * as views from './views'