@likec4/generators 1.52.0 → 1.53.0

package/src/likec4/schemas/expression.ts

@@ -0,0 +1,218 @@
+import * as z from 'zod/v4'
+import * as common from './common'
+
+export const refModel = z.strictObject({
+  model: common.fqn,
+  project: z.string().optional(),
+})
+
+export const refDeployment = z.strictObject({
+  deployment: common.fqn,
+  element: common.fqn.nullish(),
+})
+
+export const fqnRef = z.union([
+  refModel,
+  refDeployment,
+])
+
+export const selector = z.literal(['children', 'expanded', 'descendants'])
+
+/**
+ * Accepts a value directly (shorthand for equality), or an explicit {eq: value} / {neq: value}.
+ * Replicates the EqualOperator from the core.
+ */
+function equalOp<T extends z.ZodType>(schema: T) {
+  return z.union([
+    schema.transform((value) => ({ eq: value })),
+    z.object({ eq: schema }),
+    z.object({ neq: schema }),
+  ])
+}
+
+export const whereTag = z.object({ tag: equalOp(common.tag) })
+export const whereKind = z.object({ kind: equalOp(common.kind) })
+export const whereMetadata = z.object({
+  metadata: z.object({
+    key: z.string(),
+    value: equalOp(z.string()).optional(),
+  }),
+})
+
+export const whereParticipant = z.object({
+  participant: z.literal(['source', 'target']),
+  operator: z.union([
+    whereTag,
+    whereKind,
+    whereMetadata,
+  ]),
+})
+
+export const whereAnd = z.object({
+  get and(): z.ZodArray<typeof whereOperator> {
+    return z.array(whereOperator)
+  },
+})
+
+export const whereNot = z.object({
+  get not() {
+    return whereOperator
+  },
+})
+
+export const whereOr = z.object({
+  get or(): z.ZodArray<typeof whereOperator> {
+    return z.array(whereOperator)
+  },
+})
+
+export const whereOperator = z.union([
+  whereTag,
+  whereKind,
+  whereMetadata,
+  whereParticipant,
+  whereAnd,
+  whereOr,
+  whereNot,
+])
+
+// ---- ModelFqnExpr base variants ----
+export const wildcardExpr = z.object({ wildcard: z.literal(true) })
+export const refExpr = z.object({
+  ref: fqnRef,
+  selector: selector.optional(),
+})
+export const elementKindExpr = z.object({
+  elementKind: common.kind,
+  isEqual: z.boolean(),
+})
+export const elementTagExpr = z.object({
+  elementTag: common.tag,
+  isEqual: z.boolean(),
+})
+
+export const fqnExpr = z.union([
+  wildcardExpr,
+  refExpr,
+  elementKindExpr,
+  elementTagExpr,
+])
+
+const fqnExprWhere = z.strictObject({
+  where: z.strictObject({
+    expr: fqnExpr,
+    condition: whereOperator,
+  }),
+})
+
+export const fqnExprOrWhere = z.union([
+  fqnExpr,
+  fqnExprWhere,
+])
+
+/**
+ * Common custom properties that apply to both elements and relations
+ */
+const commonCustomProperties = z.object({
+  title: z.string(),
+  description: common.markdownOrString,
+  technology: z.string(),
+  notation: z.string(),
+  notes: common.markdownOrString,
+  navigateTo: common.viewId,
+  color: common.color,
+})
+
+const customElementProperties = z.object({
+  ...commonCustomProperties.shape,
+  shape: common.shape,
+  icon: common.icon,
+  iconColor: common.color,
+  iconSize: common.size,
+  iconPosition: common.iconPosition,
+  border: common.border,
+  opacity: common.opacity,
+  multiple: z.boolean(),
+  size: common.size,
+  padding: common.size,
+  textSize: common.size,
+}).partial()
+
+const customRelationProperties = z.object({
+  ...commonCustomProperties.shape,
+  line: common.line,
+  head: common.arrow,
+  tail: common.arrow,
+}).partial()
+
+export const fqnExprCustom = z.strictObject({
+  custom: customElementProperties.extend({
+    expr: fqnExprOrWhere,
+  }),
+})
+
+export const fqnExprAny = z.union([
+  fqnExprOrWhere,
+  fqnExprCustom,
+])
+
+// ---- ModelRelationExpr base variants ----
+export const directRelationExpr = z.object({
+  source: fqnExpr,
+  target: fqnExpr,
+  isBidirectional: z.boolean().optional(),
+})
+export const incomingRelationExpr = z.object({ incoming: fqnExpr })
+export const outgoingRelationExpr = z.object({ outgoing: fqnExpr })
+export const inoutRelationExpr = z.object({ inout: fqnExpr })
+
+export const relationExpr = z.union([
+  directRelationExpr,
+  incomingRelationExpr,
+  outgoingRelationExpr,
+  inoutRelationExpr,
+])
+
+export const relationExprOrWhere = z.union([
+  relationExpr,
+  z.strictObject({
+    where: z.strictObject({
+      expr: relationExpr,
+      condition: whereOperator,
+    }),
+  }),
+])
+
+export const relationExprCustom = z.strictObject({
+  customRelation: customRelationProperties.extend({
+    expr: relationExprOrWhere,
+  }),
+})
+
+export const relationExprAny = z.union([
+  relationExprOrWhere,
+  relationExprCustom,
+])
+
+// Where expression - wraps either a fqn or relation base expression with a condition
+export const whereExpr = z.object({
+  where: z.object({
+    expr: z.union([
+      fqnExpr,
+      relationExpr,
+    ]),
+    condition: whereOperator,
+  }),
+})
+
+/**
+ * Full model expression, union of all fqn and relation expression variants.
+ * Replicates ModelExpression from the core.
+ */
+export const expression = z.union([
+  fqnExpr,
+  fqnExprCustom,
+  relationExpr,
+  relationExprCustom,
+  whereExpr,
+])

package/src/likec4/schemas/index.ts

@@ -0,0 +1,83 @@
+import type z from 'zod/v4'
+import * as common from './common'
+import * as deployment from './deployment'
+import * as expr from './expression'
+import { likec4data } from './likec4data'
+import * as model from './model'
+import * as specification from './specification'
+import * as views from './views'
+
+export const schemas = {
+  common,
+  expr,
+  specification,
+  model,
+  deployment,
+  views,
+  likec4data,
+}
+
+export namespace schemas {
+  export namespace common {
+  }
+
+  export namespace expr {
+    export type Input = z.input<typeof schemas.expr.expression>
+    export type Data = z.output<typeof schemas.expr.expression>
+  }
+
+  export namespace specification {
+    export type Input = z.input<typeof schemas.specification.schema>
+  }
+
+  export namespace model {
+    export type Input = z.input<typeof schemas.model.schema>
+
+    export namespace element {
+      export type Input = z.input<typeof schemas.model.element>
+      export type Data = z.output<typeof schemas.model.element>
+    }
+
+    export namespace relationship {
+      export type Input = z.input<typeof schemas.model.relationship>
+      export type Data = z.output<typeof schemas.model.relationship>
+    }
+  }
+
+  export namespace deployment {
+    export type Input = z.input<typeof schemas.deployment.schema>
+    export type Data = z.output<typeof schemas.deployment.schema>
+
+    export namespace node {
+      export type Input = z.input<typeof schemas.deployment.node>
+      export type Data = z.output<typeof schemas.deployment.node>
+    }
+
+    export namespace instance {
+      export type Input = z.input<typeof schemas.deployment.instance>
+      export type Data = z.output<typeof schemas.deployment.instance>
+    }
+
+    export namespace element {
+      export type Input = z.input<typeof schemas.deployment.element>
+      export type Data = z.output<typeof schemas.deployment.element>
+    }
+
+    export namespace relationship {
+      export type Input = z.input<typeof schemas.deployment.relationship>
+      export type Data = z.output<typeof schemas.deployment.relationship>
+    }
+  }
+
+  export namespace views {
+    export namespace elementView {
+      export type Input = z.input<typeof schemas.views.elementView>
+      export type Data = z.output<typeof schemas.views.elementView>
+    }
+  }
+
+  export namespace likec4data {
+    export type Input = z.input<typeof schemas.likec4data>
+    export type Data = z.output<typeof schemas.likec4data>
+  }
+}

package/src/likec4/schemas/likec4data.ts

@@ -0,0 +1,76 @@
+import { LikeC4StylesConfigSchema } from '@likec4/config'
+import { produce } from 'immer'
+import { entries, isDeepEqual, isEmptyish, mapValues } from 'remeda'
+import * as z from 'zod/v4'
+import * as deployment from './deployment'
+import * as model from './model'
+import * as specification from './specification'
+import { views } from './views'
+
+const likec4dataPreTransform = z
+  .object({
+    ...model.schema.shape,
+    views: views,
+    project: z.object({
+      id: z.string(),
+      styles: LikeC4StylesConfigSchema.nullish(),
+    }),
+    deployment: deployment.schema,
+    deployments: deployment.schema,
+    specification: specification.schema,
+  })
+  .partial()
+  .readonly()
+
+export const likec4data = likec4dataPreTransform.transform(normalizeStyles)
+
+type LikeC4Data = z.output<typeof likec4dataPreTransform>
+type ElementData = z.output<typeof model.element>
+type ElementSpecificationData = z.output<typeof specification.element>
+
+function normalizeStyles(data: LikeC4Data): LikeC4Data {
+  const elementSpecs = data.specification?.elements
+  if (!isEmptyish(elementSpecs) && !isEmptyish(data.elements)) {
+    data = {
+      ...data,
+      elements: mapValues(data.elements, element => normalizeElementStyles(element, elementSpecs)),
+    }
+  }
+
+  return data
+}
+
+function normalizeElementStyles(element: ElementData, specs: Record<string, ElementSpecificationData>): ElementData {
+  const spec = specs[element.kind]
+  if (!spec) {
+    return element
+  }
+  const specStyle = spec.style ?? {}
+  return produce(element, draft => {
+    for (
+      // Remove properties that are the same as the specification
+      const key of [
+        'description',
+        'technology',
+        'title',
+        'tags',
+        'summary',
+      ] satisfies (keyof ElementSpecificationData)[]
+    ) {
+      const specValue = spec[key]
+      const elementValue = element[key]
+      if (isDeepEqual(specValue, elementValue)) {
+        delete draft[key]
+      }
+    }
+    if (!element.style) {
+      return
+    }
+    // Remove style properties that are the same as the specification
+    for (const [key, value] of entries(specStyle)) {
+      if (isDeepEqual(element.style?.[key], value)) {
+        delete draft.style![key]
+      }
+    }
+  })
+}

package/src/likec4/schemas/model.ts

@@ -0,0 +1,127 @@
+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'
+
+// export const elementTree = z.object({
+//     id: common.fqn.optional(),
+//     name: common.id.optional(),
+//     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(),
+//     get children(): z.ZodOptional<z.ZodArray<typeof elementTree>> {
+//       return z.array(elementTree).optional()
+//     },
+//   })
+// .readonly()
+
+/**
+ * Replicates the {@link Element} from the core,
+ * less strict, as the generator should be able to handle missing fields and provide defaults.
+ */
+export const element = z
+  .object({
+    ...common.props.shape,
+    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(),
+  })
+  .transform(value => {
+    let { shape, color, icon, ...rest } = value
+    if (shape || color || icon) {
+      rest = 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 pickBy(rest, isNonNullish)
+  })
+  .readonly()
+
+const relationshipEndpoint = z.union([
+  common.fqn,
+  z.strictObject({
+    model: common.fqn,
+  }),
+]).transform(v => (typeof v === 'string' ? { model: v } : v))
+
+const relationshipId = common.id.transform(value => value as unknown as RelationId)
+
+export const relationship = z.object({
+  ...common.props.shape,
+  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(),
+})
+  .transform(pickBy(isNonNullish))
+  .readonly()
+
+// ============ Top-Level Schema ============
+
+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(),
+    //     isArray(v) ?
+    //       indexBy(
+    //         v,
+    //         (r, idx) => r.id as string ?? stringHash(`${r.source.model}, ${r.target.model}, ${r.kind ?? ''}, ${idx}`),
+    //       ) :
+    //       v
+    //   )
+    //   .optional(),
+    // views: z.union([
+    //   z.record(viewId, ElementViewSchema),
+    //   z.array(ElementViewSchema)
+    //     .transform(indexBy(v => v.id as string)),
+    // ]),
+    // project: z.object({
+    //   id: z.string(),
+    //   styles: LikeC4StylesConfigSchema.nullish(),
+    // }),
+    // specification: SpecificationSchema,
+  })

package/src/likec4/schemas/specification.ts

@@ -0,0 +1,83 @@
+import type {
+  ElementSpecification,
+  RelationshipSpecification,
+} from '@likec4/core/types'
+import { isNonNullish, mapToObj, pickBy } from 'remeda'
+import * as z from 'zod/v4'
+import * as common from './common'
+
+/**
+ * Replicates the {@link ElementSpecification} from the core,
+ * less strict, as the generator should be able to handle missing fields and provide defaults.
+ */
+export const element = z
+  .object({
+    tags: common.tags.nullable(),
+    title: z.string().nullable(),
+    summary: common.markdownOrString.nullable(),
+    description: common.markdownOrString.nullable(),
+    technology: z.string().nullable(),
+    notation: z.string().nullable(),
+    links: common.links.nullable(),
+    style: common.style.nullable(),
+  })
+  .partial()
+  .transform(pickBy(isNonNullish))
+
+/**
+ * Replicates the {@link RelationshipSpecification} from the core,
+ * less strict, as the generator should be able to handle missing fields and provide defaults.
+ */
+export const relationship = z
+  .object({
+    technology: z.string().nullable(),
+    notation: z.string().nullable(),
+    color: common.color.nullable(),
+    line: common.line.nullable(),
+    head: common.arrow.nullable(),
+    tail: common.arrow.nullable(),
+  })
+  .partial()
+  .transform(pickBy(isNonNullish))
+
+export const tagSpec = z
+  .object({
+    color: z
+      .string()
+      .regex(/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/)
+      .optional()
+      .catch(undefined),
+  })
+  .partial()
+  .transform(pickBy(isNonNullish))
+
+export const schema = z
+  .object({
+    /**
+     * Element kinds specifications, where key is the kind name
+     */
+    elements: z.record(common.kind, element),
+
+    /**
+     * Element kinds specifications, where key is the kind name
+     */
+    deployments: z.record(common.kind, element),
+
+    /**
+     * Relationship kinds specifications, where key is the kind name
+     */
+    relationships: z.record(common.kind, relationship),
+
+    /**
+     * Tag specifications, where key is the tag name
+     * Or an array of tags, if no additional properties are needed for tags (like color)
+     */
+    tags: z.union([
+      z.record(
+        common.tag,
+        tagSpec,
+      ),
+      z.array(common.tag).transform(tags => mapToObj(tags, t => [t, {} as Record<string, any>] as const)),
+    ]),
+  })
+  .partial()