@likec4/generators 1.52.0 → 1.53.0

package/src/likec4/operators/views.ts

@@ -0,0 +1,390 @@
+import {
+  hasProp,
+  invariant,
+  nonexhaustive,
+} from '@likec4/core'
+import { CompositeGeneratorNode, NL } from 'langium/generate'
+import { hasAtLeast, values } from 'remeda'
+import { schemas } from '../schemas'
+import {
+  type Op,
+  body,
+  foreach,
+  foreachNewLine,
+  guard,
+  indent,
+  inlineText,
+  lines,
+  merge,
+  print,
+  printProperty,
+  property,
+  select,
+  separateComma,
+  space,
+  spaceBetween,
+  withctx,
+  zodOp,
+} from './base'
+import { expression } from './expressions'
+import {
+  colorProperty,
+  descriptionProperty,
+  linksProperty,
+  notationProperty,
+  notesProperty,
+  styleProperties,
+  tagsProperty,
+  technologyProperty,
+  titleProperty,
+} from './properties'
+
+const viewTitleProperty = <A extends { title?: string | null | undefined }>(): Op<A> =>
+  property(
+    'title',
+    spaceBetween(
+      print('title'),
+      inlineText(),
+    ),
+  )
+
+export const viewRulePredicate = zodOp(schemas.views.viewRulePredicate)(({ ctx, exec }) => {
+  let exprs
+  let type
+  if ('include' in ctx) {
+    exprs = ctx.include
+    type = 'include'
+  } else if ('exclude' in ctx) {
+    exprs = ctx.exclude
+    type = 'exclude'
+  }
+  invariant(exprs && type, 'Invalid view rule predicate')
+
+  if (!hasAtLeast(exprs, 1)) {
+    return
+  }
+
+  const isMultiple = hasAtLeast(exprs, 2)
+
+  const exprOp = withctx(exprs)(
+    foreach(
+      expression(),
+      separateComma(isMultiple),
+    ),
+  )
+
+  exec(
+    ctx,
+    merge(
+      print(type),
+      ...(isMultiple ? [indent(exprOp)] : [space(), exprOp]),
+    ),
+  )
+})
+
+export const viewRuleStyle = zodOp(schemas.views.viewRuleStyle)(
+  spaceBetween(
+    print('style'),
+    property(
+      'targets',
+      foreach(
+        expression(),
+        separateComma(),
+      ),
+    ),
+    body('{', '}')(
+      notationProperty(),
+      property('style', styleProperties()),
+    ),
+  ),
+)
+export const viewRuleGroup = zodOp(schemas.views.viewRuleGroup)(({ ctx, exec }) => {
+  throw new Error('not implemented')
+})
+export const viewRuleGlobalStyle = zodOp(schemas.views.viewRuleGlobalStyle)(({ ctx, exec }) => {
+  throw new Error('not implemented')
+})
+export const viewRuleGlobalPredicate = zodOp(schemas.views.viewRuleGlobalPredicate)(({ ctx, exec }) => {
+  throw new Error('not implemented')
+})
+
+const mapping = {
+  'TB': 'TopBottom',
+  'BT': 'BottomTop',
+  'LR': 'LeftRight',
+  'RL': 'RightLeft',
+} as const
+export const viewRuleAutoLayout = zodOp(schemas.views.viewRuleAutoLayout)(
+  spaceBetween(
+    print('autoLayout'),
+    property(
+      'direction',
+      print(v => mapping[v]),
+    ),
+    guard(
+      hasProp('rankSep'),
+      spaceBetween(
+        printProperty('rankSep'),
+        printProperty('nodeSep'),
+      ),
+    ),
+  ),
+)
+
+export const viewRuleRank = zodOp(schemas.views.viewRuleRank)(({ ctx, exec }) => {
+  throw new Error('not implemented')
+})
+
+export const elementViewRule = zodOp(schemas.views.elementViewRule)(
+  ({ ctx, exec }) => {
+    if ('include' in ctx || 'exclude' in ctx) {
+      return exec(ctx, viewRulePredicate())
+    }
+    if ('groupRules' in ctx) {
+      return exec(ctx, viewRuleGroup())
+    }
+    if ('rank' in ctx) {
+      return exec(ctx, viewRuleRank())
+    }
+    if ('direction' in ctx) {
+      return exec(ctx, viewRuleAutoLayout())
+    }
+    if ('styleId' in ctx) {
+      return exec(ctx, viewRuleGlobalStyle())
+    }
+    if ('predicateId' in ctx) {
+      return exec(ctx, viewRuleGlobalPredicate())
+    }
+    if ('targets' in ctx && 'style' in ctx) {
+      return exec(ctx, viewRuleStyle())
+    }
+    nonexhaustive(ctx)
+  },
+)
+
+export const elementView = zodOp(schemas.views.elementView.partial({ _type: true }))(
+  spaceBetween(
+    print('view'),
+    print(v => v.id),
+    property(
+      'viewOf',
+      spaceBetween(
+        print('of'),
+        print(),
+      ),
+    ),
+    body(
+      lines(2)(
+        // Properties on each line
+        lines(
+          tagsProperty(),
+          viewTitleProperty(),
+          descriptionProperty(),
+          linksProperty(),
+        ),
+        property(
+          'rules',
+          foreachNewLine(
+            elementViewRule(),
+          ),
+        ),
+      ),
+    ),
+  ),
+)
+
+// --- Deployment View ---
+
+export const deploymentViewRule = zodOp(schemas.views.deploymentViewRule)(
+  ({ ctx, exec }) => {
+    if ('include' in ctx || 'exclude' in ctx) {
+      return exec(ctx, viewRulePredicate())
+    }
+    if ('direction' in ctx) {
+      return exec(ctx, viewRuleAutoLayout())
+    }
+    if ('styleId' in ctx) {
+      return exec(ctx, viewRuleGlobalStyle())
+    }
+    if ('predicateId' in ctx) {
+      return exec(ctx, viewRuleGlobalPredicate())
+    }
+    if ('targets' in ctx && 'style' in ctx) {
+      return exec(ctx, viewRuleStyle())
+    }
+    nonexhaustive(ctx)
+  },
+)
+
+export const deploymentView = zodOp(schemas.views.deploymentView.partial({ _type: true }))(
+  spaceBetween(
+    print('deployment view'),
+    print(v => v.id),
+    body(
+      lines(2)(
+        // Properties on each line
+        lines(
+          tagsProperty(),
+          viewTitleProperty(),
+          descriptionProperty(),
+          linksProperty(),
+        ),
+        property(
+          'rules',
+          foreachNewLine(
+            deploymentViewRule(),
+          ),
+        ),
+      ),
+    ),
+  ),
+)
+
+// --- Dynamic View ---
+
+export const dynamicStep = zodOp(schemas.views.dynamicStep)(
+  spaceBetween(
+    print(v => v.source),
+    print(v => v.isBackward ? '<-' : '->'),
+    print(v => v.target),
+    body(
+      lines(
+        titleProperty(),
+        technologyProperty(),
+        descriptionProperty(),
+        notesProperty(),
+        property('navigateTo'),
+        notationProperty(),
+        colorProperty(),
+        property('line'),
+        property('head'),
+        property('tail'),
+      ),
+    ),
+  ),
+)
+
+export const dynamicStepsSeries = zodOp(schemas.views.dynamicStepsSeries)(({ ctx, exec }) => {
+  throw new Error('Not implemented')
+})
+
+export const dynamicStepsParallel = zodOp(schemas.views.dynamicStepsParallel)(({ ctx, exec }) => {
+  throw new Error('Not implemented')
+})
+
+export const dynamicViewStep = zodOp(schemas.views.dynamicViewStep)(({ ctx, exec }) => {
+  if ('__series' in ctx) {
+    return exec(ctx, dynamicStepsSeries())
+  }
+  if ('__parallel' in ctx) {
+    return exec(ctx, dynamicStepsParallel())
+  }
+  return exec(ctx, dynamicStep())
+})
+
+export const dynamicViewIncludeRule = zodOp(schemas.views.dynamicViewIncludeRule)(({ ctx, exec }) => {
+  if (!hasAtLeast(ctx.include, 1)) {
+    return
+  }
+
+  const isMultiple = hasAtLeast(ctx.include, 2)
+
+  const exprOp = withctx(ctx.include)(
+    foreach(
+      expression(),
+      separateComma(isMultiple),
+    ),
+  )
+
+  exec(
+    ctx,
+    merge(
+      print('include'),
+      ...(isMultiple ? [indent(exprOp)] : [space(), exprOp]),
+    ),
+  )
+})
+
+export const dynamicViewRule = zodOp(schemas.views.dynamicViewRule)(
+  ({ ctx, exec }) => {
+    if ('include' in ctx) {
+      return exec(ctx, dynamicViewIncludeRule())
+    }
+    if ('predicateId' in ctx) {
+      return exec(ctx, viewRuleGlobalPredicate())
+    }
+    if ('targets' in ctx && 'style' in ctx) {
+      return exec(ctx, viewRuleStyle())
+    }
+    if ('styleId' in ctx) {
+      return exec(ctx, viewRuleGlobalStyle())
+    }
+    if ('direction' in ctx) {
+      return exec(ctx, viewRuleAutoLayout())
+    }
+    nonexhaustive(ctx)
+  },
+)
+
+export const dynamicView = zodOp(schemas.views.dynamicView.partial({ _type: true }))(
+  spaceBetween(
+    print('dynamic view'),
+    print(v => v.id),
+    body(
+      lines(2)(
+        lines(
+          tagsProperty(),
+          viewTitleProperty(),
+          descriptionProperty(),
+          linksProperty(),
+          property('variant'),
+        ),
+        property(
+          'steps',
+          foreachNewLine(
+            dynamicViewStep(),
+          ),
+        ),
+        property(
+          'rules',
+          foreachNewLine(
+            dynamicViewRule(),
+          ),
+        ),
+      ),
+    ),
+  ),
+)
+
+// --- Parsed View ---
+export const anyView = zodOp(schemas.views.anyView)(({ ctx, exec }) => {
+  if ('_type' in ctx) {
+    if (ctx._type == 'element') {
+      return exec(ctx, elementView())
+    }
+    if (ctx._type === 'deployment') {
+      return exec(ctx, deploymentView())
+    }
+    if (ctx._type === 'dynamic') {
+      return exec(ctx, dynamicView())
+    }
+  }
+  nonexhaustive(ctx)
+})
+
+export const views = zodOp(schemas.views.views)(
+  body('views')(
+    select(
+      ctx => values(ctx),
+      foreach(
+        anyView(),
+        {
+          // Extra line between
+          separator: new CompositeGeneratorNode().appendNewLine().appendNewLine(),
+          // Add empty line before first view (if not the last one)
+          prefix: (_, index, isLast) => index === 0 && !isLast ? NL : undefined,
+        },
+      ),
+    ),
+  ),
+)

package/src/likec4/schemas/common.ts

@@ -0,0 +1,123 @@
+import {
+  BorderStyles,
+  ElementShapes,
+  IconPositions,
+  RelationshipArrowTypes,
+  Sizes,
+  ThemeColors,
+} from '@likec4/core/styles'
+import {
+  type CustomColor,
+  type Link,
+  type scalar,
+  exact,
+} from '@likec4/core/types'
+import * as z from 'zod/v4'
+
+export const id = z
+  .string()
+  .regex(/^[a-zA-Z0-9_.-]+$/, 'id must consist of alphanumeric characters, underscores or hyphens')
+
+export const viewId = id.transform(value => value as unknown as scalar.ViewId)
+
+export const fqn = z
+  .string()
+  .regex(/^[a-zA-Z0-9_.-]+$/, 'FQN must consist of alphanumeric characters, dots, underscores or hyphens')
+  .transform(value => value as unknown as scalar.Fqn)
+
+export const kind = z
+  .string()
+  .regex(/^[a-zA-Z0-9_-]+$/, 'Kind must consist of alphanumeric characters, underscores or hyphens')
+  .transform(value => value as unknown as scalar.ElementKind)
+
+export const opacity = z
+  .int()
+  .min(0, 'Opacity must be between 0 and 100')
+  .max(100, 'Opacity must be between 0 and 100')
+
+export const shape = z.literal(ElementShapes)
+
+export const icon = z.string().nonempty('Icon cannot be empty').transform(value => value as unknown as scalar.Icon)
+
+export const border = z
+  .literal(BorderStyles)
+
+export const size = z.literal(Sizes)
+
+export const iconPosition = z
+  .literal(IconPositions)
+
+export const arrow = z
+  .literal(RelationshipArrowTypes)
+
+export const line = z
+  .literal(['dashed', 'solid', 'dotted'])
+
+export const link = z.union([
+  z.string(),
+  z.object({
+    title: z.string().optional(),
+    url: z.string(),
+  }),
+]).transform(
+  value => exact(typeof value === 'string' ? { url: value } : value) as Link,
+)
+
+export const links = z.array(link).readonly()
+
+export const themeColor = z.literal(ThemeColors)
+
+export const customColor = z
+  .custom<string & Record<never, never>>()
+  .refine(v => typeof v === 'string', 'Custom color name must be a string')
+  .transform(value => value as unknown as CustomColor)
+
+export const tag = z
+  .string()
+  .nonempty('Tag cannot be empty')
+  .transform(tag => (tag.startsWith('#') ? tag.slice(1) : tag) as unknown as scalar.Tag)
+
+export const tags = z.array(tag).readonly()
+
+export const markdownOrString = z.union([
+  z.string(),
+  z.strictObject({ md: z.string() }),
+  z.strictObject({ txt: z.string() }),
+]).transform(v => (typeof v === 'string' ? { txt: v } : v) as scalar.MarkdownOrString)
+
+export const color = themeColor.or(customColor)
+
+export const style = z
+  .object({
+    shape: shape,
+    icon: icon,
+    iconColor: color,
+    iconSize: size,
+    iconPosition: iconPosition,
+    color: color,
+    border: border,
+    opacity: opacity,
+    size: size,
+    padding: size,
+    textSize: size,
+    multiple: z.boolean(),
+  })
+  .partial()
+
+export const metadataValue = z.union([z.string(), z.boolean(), z.number()])
+
+export const metadata = z.record(z.string(), metadataValue.or(z.array(metadataValue)))
+
+export const props = z
+  .object({
+    tags: tags.nullable(),
+    title: z.string(),
+    summary: markdownOrString.nullable(),
+    description: markdownOrString.nullable(),
+    notation: z.string().nullable(),
+    technology: z.string().nullable(),
+    links: links.nullable(),
+    metadata: metadata,
+  })
+  // all properties are optional, as the generator should be able to handle missing fields and provide defaults
+  .partial()

package/src/likec4/schemas/deployment.ts

@@ -0,0 +1,113 @@
+import {
+  RelationId,
+} from '@likec4/core/types'
+import { produce } from 'immer'
+import { indexBy, isArray, isNonNullish, pickBy, prop, randomString } from 'remeda'
+import * as z from 'zod/v4'
+import * as common from './common'
+import * as expression from './expression'
+
+export const node = common.props
+  .extend({
+    id: common.fqn,
+    kind: common.kind,
+    style: common.style.optional(),
+    /**
+     * Allowing shape, color and icon to be defined at the element level for convenience,
+     * they will be moved to the style property during parsing
+     * (and will override properties)
+     */
+    shape: common.shape.optional(),
+    color: common.color.optional(),
+    icon: common.icon.optional(),
+  })
+  .readonly()
+  .transform(value => {
+    const { shape, color, icon, ...rest } = value
+    if (shape || color || icon) {
+      return produce(rest, draft => {
+        draft.style = rest.style || {}
+        draft.style.shape = shape ?? rest.style?.shape
+        draft.style.color = color ?? rest.style?.color
+        draft.style.icon = icon ?? rest.style?.icon
+      })
+    }
+    return rest
+  })
+  .transform(pickBy(isNonNullish))
+
+export const instance = common.props
+  .extend({
+    id: common.fqn,
+    element: common.fqn,
+    style: common.style.optional(),
+    /**
+     * Allowing shape, color and icon to be defined at the element level for convenience,
+     * they will be moved to the style property during parsing
+     * (and will override properties)
+     */
+    shape: common.shape.optional(),
+    color: common.color.optional(),
+    icon: common.icon.optional(),
+  })
+  .readonly()
+  .transform(value => {
+    const { shape, color, icon, ...rest } = value
+    if (shape || color || icon) {
+      return produce(rest, draft => {
+        draft.style = rest.style || {}
+        draft.style.shape = shape ?? rest.style?.shape
+        draft.style.color = color ?? rest.style?.color
+        draft.style.icon = icon ?? rest.style?.icon
+      })
+    }
+    return rest
+  })
+  .transform(pickBy(isNonNullish))
+
+const relationshipEndpoint = expression.refDeployment
+
+const relationshipId = common.id.transform(value => value as unknown as RelationId)
+
+export const relationship = common.props
+  .extend({
+    id: relationshipId.optional(),
+    title: z.string().nullish(),
+    source: relationshipEndpoint,
+    target: relationshipEndpoint,
+    navigateTo: common.viewId.nullish(),
+    color: common.color.nullish(),
+    kind: common.kind.nullish(),
+    line: common.line.nullish(),
+    head: common.arrow.nullish(),
+    tail: common.arrow.nullish(),
+  })
+  .readonly()
+  .transform(pickBy(isNonNullish))
+
+// ============ Top-Level Schema ============
+
+export const element = z.union([node, instance])
+
+const elements = z.record(common.fqn, element)
+const relationships = z.record(relationshipId, relationship)
+
+const genRelationshipId = (r: z.output<typeof relationship>): RelationId => r.id ?? randomString(8) as RelationId
+
+export const schema = z
+  .object({
+    elements: z
+      .union([
+        elements,
+        z.array(element),
+      ])
+      .transform(v => isArray(v) ? indexBy(v, prop('id')) as unknown as z.output<typeof elements> : v)
+      .optional(),
+    relations: z
+      .union([
+        relationships,
+        z.array(relationship),
+      ])
+      .transform(v => isArray(v) ? indexBy(v, genRelationshipId) as unknown as z.output<typeof relationships> : v)
+      .optional(),
+  })