@likec4/generators 1.52.0 → 1.53.0

package/src/likec4/operators/likec4data.ts

@@ -0,0 +1,33 @@
+import * as z from 'zod/v4'
+import { schemas } from '../schemas'
+import { lines, property, zodOp } from './base'
+import { deployment } from './deployment'
+import { model } from './model'
+import { specification } from './specification'
+import { views } from './views'
+
+const likec4dataSchema = z.object({
+  // ...schemas.likec4data.shape,
+})
+
+export const likec4data = zodOp(schemas.likec4data)(
+  lines(2)(
+    property(
+      'specification',
+      specification(),
+    ),
+    model(),
+    property(
+      'deployment',
+      deployment(),
+    ),
+    property(
+      'deployments',
+      deployment(),
+    ),
+    property(
+      'views',
+      views(),
+    ),
+  ),
+)

package/src/likec4/operators/model.ts

@@ -0,0 +1,222 @@
+import type { Fqn } from '@likec4/core/types'
+import { 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,
+  property,
+  select,
+  spaceBetween,
+  when,
+  withctx,
+  zodOp,
+} from './base'
+import { fqnRef } from './expressions.ts'
+import {
+  colorProperty,
+  descriptionProperty,
+  linksProperty,
+  metadataProperty,
+  styleProperties,
+  summaryProperty,
+  tagsProperty,
+  technologyProperty,
+} from './properties'
+
+// --- Tree building ---
+
+type ElementData = schemas.model.element.Data
+
+type ElementTreeNode = ElementData & {
+  children?: ElementTreeNode[]
+}
+
+function buildTree(elements: ElementData[]): {
+  roots: readonly ElementTreeNode[]
+  nodes: ReadonlyMap<Fqn, ElementTreeNode>
+  exists: (fqn: Fqn) => boolean
+} {
+  const nodes = new Map<Fqn, ElementTreeNode>()
+  const roots: ElementTreeNode[] = []
+  const sorted = pipe(
+    elements,
+    sortParentsFirst,
+  )
+
+  for (const element of sorted) {
+    const node: ElementTreeNode = { ...element, children: [] }
+    nodes.set(element.id, node)
+
+    const parentId = parentFqn(element.id)
+    const parent = parentId ? nodes.get(parentId) : undefined
+
+    if (parent) {
+      parent.children!.push(node)
+    } else {
+      roots.push(node)
+    }
+  }
+
+  return {
+    roots,
+    nodes,
+    exists: (fqn: Fqn) => nodes.has(fqn),
+  }
+}
+
+// --- Predicates ---
+
+function hasStyleProps(el: ElementData): 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.model.element)(
+  lines(
+    tagsProperty(),
+    technologyProperty(),
+    summaryProperty(),
+    descriptionProperty(),
+    linksProperty(),
+    metadataProperty(),
+    select(
+      e => hasStyleProps(e) ? e.style : undefined,
+      body('style')(
+        styleProperties(),
+      ),
+    ),
+  ),
+)
+
+function elementTree() {
+  return function elementTreeNodeOp<E extends ElementTreeNode>(
+    { ctx, out }: Ctx<E>,
+  ): Ctx<E> {
+    const el = ctx
+    const needsBody = (ctx.children?.length ?? 0) > 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()),
+            ...(ctx.children ?? []).map(node => withctx(node, elementTree())),
+          ),
+        ),
+      )
+    }
+
+    return spaceBetween(...inline)({ ctx, out })
+  }
+}
+
+// --- Relationship ---
+
+function hasRelationStyle(rel: schemas.model.relationship.Data): boolean {
+  return !!(
+    rel.color || rel.line || rel.head || rel.tail
+  )
+}
+
+function hasRelationProps(rel: schemas.model.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.model.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 model = zodOp(schemas.model.schema)(
+  body('model')(
+    lines(2)(
+      select(
+        d => buildTree(d.elements ? values(d.elements) : []).roots,
+        lines(2)(
+          foreach(
+            elementTree(),
+          ),
+        ),
+      ),
+      select(
+        d => d.relations ? values(d.relations) : undefined,
+        lines(2)(
+          foreach(
+            relationship(),
+          ),
+        ),
+      ),
+    ),
+  ),
+)

package/src/likec4/operators/properties.ts

@@ -0,0 +1,244 @@
+import { type Color, type ElementStyle, type Link, type MarkdownOrString, exact } from '@likec4/core/types'
+import { entries, isArray, isNot, isString, piped } from 'remeda'
+import type { ConditionalKeys } from 'type-fest'
+import * as common from '../schemas/common'
+import type { Op } from './base'
+import {
+  body,
+  foreach,
+  foreachNewLine,
+  guard,
+  inlineText,
+  lines,
+  markdownOrString,
+  operation,
+  print,
+  property,
+  select,
+  separateNewLine,
+  spaceBetween,
+  text,
+  zodOp,
+} from './base'
+
+/**
+ * Print a property from the context as a text.
+ */
+export function textProperty<A>(
+  propertyName: ConditionalKeys<NoInfer<A>, string | undefined | null>,
+  keyword?: string,
+): Op<A> {
+  return select(
+    e => e[propertyName] as string,
+    spaceBetween(
+      print(keyword ?? propertyName as string),
+      text(),
+    ),
+  )
+}
+
+/**
+ * Print a property from the context as a markdown string.
+ */
+export function markdownProperty<A>(
+  propertyName: ConditionalKeys<NoInfer<A>, string | MarkdownOrString | undefined | null>,
+  keyword?: string,
+): Op<A> {
+  return select(
+    e => e[propertyName] as MarkdownOrString,
+    spaceBetween(
+      print(keyword ?? propertyName as string),
+      markdownOrString(),
+    ),
+  )
+}
+
+export const titleProperty = <A extends { title?: string | null | undefined }>(): Op<A> =>
+  property(
+    'title',
+    spaceBetween(
+      print('title'),
+      text(),
+    ),
+  )
+
+export const summaryProperty = <A extends { summary?: string | MarkdownOrString | null | undefined }>(): Op<A> =>
+  property(
+    'summary',
+    spaceBetween(
+      print('summary'),
+      markdownOrString(),
+    ),
+  )
+
+export const descriptionProperty = <A extends { description?: string | MarkdownOrString | null | undefined }>(): Op<
+  A
+> =>
+  property(
+    'description',
+    spaceBetween(
+      print('description'),
+      markdownOrString(),
+    ),
+  )
+
+export const notesProperty = <A extends { notes?: string | MarkdownOrString | null | undefined }>(): Op<A> =>
+  property(
+    'notes',
+    spaceBetween(
+      print('notes'),
+      markdownOrString(),
+    ),
+  )
+
+export const technologyProperty = <A extends { technology?: string | null | undefined }>(): Op<A> =>
+  property(
+    'technology',
+    spaceBetween(
+      print('technology'),
+      text(),
+    ),
+  )
+
+export const notationProperty = <A extends { notation?: string | null | undefined }>(): Op<A> =>
+  property(
+    'notation',
+    spaceBetween(
+      print('notation'),
+      text(),
+    ),
+  )
+
+type MetadataValue = string | number | boolean
+function printMetadataValue(): Op<MetadataValue> {
+  return operation(({ ctx, out }) => {
+    if (isString(ctx)) {
+      return text()({ ctx, out })
+    }
+    return print()({ ctx, out })
+  })
+}
+
+export function metadataValue(): Op<MetadataValue | MetadataValue[]> {
+  return piped(
+    guard(
+      isNot(isArray),
+      printMetadataValue(),
+    ),
+    guard(
+      isArray,
+      body('[', ']')(
+        foreach(
+          printMetadataValue(),
+          {
+            appendNewLineIfNotEmpty: true,
+            suffix(element, index, isLast) {
+              return !isLast ? ',' : undefined
+            },
+          },
+        ),
+      ),
+    ),
+  )
+}
+
+export const metadataProperty = <A extends { metadata?: Record<string, MetadataValue | MetadataValue[]> | null }>(): Op<
+  A
+> =>
+  select(
+    e => e.metadata ? entries(e.metadata) : undefined,
+    body('metadata')(
+      foreach(
+        spaceBetween(
+          print(v => v[0]),
+          property('1', metadataValue()),
+        ),
+        separateNewLine(),
+      ),
+    ),
+  )
+
+export const tagsProperty = <A extends { tags?: readonly string[] | undefined | null }>(): Op<A> =>
+  property(
+    'tags',
+    print(v => v.map(t => `#${t}`).join(', ')),
+  )
+
+type LinkLike = string | { url: string; title?: string | undefined }
+
+export function linkProperty<A extends LinkLike>(): Op<A> {
+  return spaceBetween(
+    select(
+      (l): Link => typeof l === 'string' ? { url: l } : exact({ url: l.url, title: l.title }),
+      print('link'),
+      print(v => v.url),
+      property('title', inlineText()),
+    ),
+  )
+}
+
+export const linksProperty = <
+  A extends { links?: ReadonlyArray<LinkLike> | null | undefined },
+>(): Op<A> =>
+  property(
+    'links',
+    foreachNewLine(
+      linkProperty(),
+    ),
+  )
+
+export function styleBlockProperty<A extends { style?: ElementStyle | undefined | null }>(): Op<A> {
+  return select(
+    e => e.style,
+    body('style')(
+      styleProperties(),
+    ),
+  )
+}
+
+export function colorProperty<A extends { color?: Color | undefined | null }>(): Op<A> {
+  return property(
+    'color',
+    spaceBetween(
+      print('color'),
+      print(),
+    ),
+  )
+}
+
+export function opacityProperty<A extends { opacity?: number | undefined | null }>(): Op<A> {
+  return property(
+    'opacity',
+    spaceBetween(
+      print('opacity'),
+      print(v => `${v}%`),
+    ),
+  )
+}
+
+export function iconProperty<A extends { icon?: string | undefined | null }>(): Op<A> {
+  return property(
+    'icon',
+    spaceBetween(
+      print('icon'),
+      print(),
+    ),
+  )
+}
+
+export const styleProperties = zodOp(common.style)(
+  lines(
+    property('shape'),
+    colorProperty(),
+    iconProperty(),
+    property('iconColor'),
+    property('iconSize'),
+    property('iconPosition'),
+    property('border'),
+    opacityProperty(),
+    property('size'),
+    property('padding'),
+    property('textSize'),
+    property('multiple'),
+  ),
+)

package/src/likec4/operators/specification.ts

@@ -0,0 +1,119 @@
+import { entries } from 'remeda'
+import * as z from 'zod/v4'
+import * as schemas from '../schemas/specification'
+import {
+  body,
+  foreachNewLine,
+  lines,
+  print,
+  printProperty,
+  property,
+  select,
+  spaceBetween,
+  zodOp,
+} from './base'
+import {
+  colorProperty,
+  descriptionProperty,
+  linksProperty,
+  notationProperty,
+  styleProperties,
+  summaryProperty,
+  tagsProperty,
+  technologyProperty,
+  titleProperty,
+} from './properties'
+
+export const tagSpecification = zodOp(z.tuple([z.string(), schemas.tagSpec]))(
+  spaceBetween(
+    print('tag'),
+    printProperty('0'),
+    property(
+      '1',
+      property(
+        'color',
+        body(
+          spaceBetween(
+            print('color'),
+            print(),
+          ),
+        ),
+      ),
+    ),
+  ),
+)
+
+export const elementKind = (keyword: 'element' | 'deploymentNode') =>
+  zodOp(z.tuple([z.string(), schemas.element]))(
+    spaceBetween(
+      print(keyword),
+      printProperty('0'),
+      property(
+        '1',
+        body(
+          tagsProperty(),
+          titleProperty(),
+          summaryProperty(),
+          descriptionProperty(),
+          technologyProperty(),
+          notationProperty(),
+          linksProperty(),
+          property(
+            'style',
+            body('style')(
+              styleProperties(),
+            ),
+          ),
+        ),
+      ),
+    ),
+  )
+
+export const relationshipKind = zodOp(z.tuple([z.string(), schemas.relationship]))(
+  spaceBetween(
+    print('relationship'),
+    printProperty('0'),
+    property(
+      '1',
+      body(
+        technologyProperty(),
+        notationProperty(),
+        colorProperty(),
+        property('line'),
+        property('head'),
+        property('tail'),
+      ),
+    ),
+  ),
+)
+
+export const specification = zodOp(schemas.schema)(
+  body('specification')(
+    lines(2)(
+      select(
+        c => c.elements && entries(c.elements),
+        foreachNewLine(
+          elementKind('element')(),
+        ),
+      ),
+      select(
+        c => c.deployments && entries(c.deployments),
+        foreachNewLine(
+          elementKind('deploymentNode')(),
+        ),
+      ),
+      select(
+        c => c.relationships && entries(c.relationships),
+        foreachNewLine(
+          relationshipKind(),
+        ),
+      ),
+      select(
+        c => c.tags && entries(c.tags),
+        foreachNewLine(
+          tagSpecification(),
+        ),
+      ),
+    ),
+  ),
+)