pe-jsonnet.jsonnet

local std = std;

{
  webApp(v):
    local name         = v.name;
    local image        = v.image;
    local replicas     = std.get(v, 'replicas', 1);
    local ingressClass = std.get(v, 'ingressClass', 'nginx');
    local serviceType  = std.get(v, 'serviceType', 'ClusterIP');
    local gatewayName  = std.get(v, 'gatewayName', 'default-gateway');
    local endpoints    = std.get(v, 'endpoints', []);

    // unique sorted ports from endpoints
    local portsUnique = std.sort(std.set([e.port for e in endpoints]));

    local deployment = {
      apiVersion: 'apps/v1',
      kind: 'Deployment',
      metadata: {
        name: name,
        labels: { 'app.kubernetes.io/name': name },
      },
      spec: {
        replicas: replicas,
        selector: { matchLabels: { 'app.kubernetes.io/name': name } },
        template: {
          metadata: { labels: { 'app.kubernetes.io/name': name } },
          spec: {
            containers: [{
              name: 'app',
              image: image,
              ports: [
                { name: 'p' + std.toString(p), containerPort: p }
                for p in portsUnique
              ],
            }],
          },
        },
      },
    };

    local service = {
      apiVersion: 'v1',
      kind: 'Service',
      metadata: {
        name: name,
        labels: { 'app.kubernetes.io/name': name },
      },
      spec: {
        type: serviceType,
        selector: { 'app.kubernetes.io/name': name },
        ports: [
          { name: 'p' + std.toString(p), port: p, targetPort: p }
          for p in portsUnique
        ],
      },
    };

    local ingresses = [
      {
        apiVersion: 'networking.k8s.io/v1',
        kind: 'Ingress',
        metadata: {
          name: name + '-' + e.name,
          labels: { 'app.kubernetes.io/name': name },
          annotations: { 'kubernetes.io/ingress.class': ingressClass },
        },
        spec: {
          rules: [{
            host: e.host,
            http: {
              paths: [{
                path: e.path,
                pathType: 'Prefix',
                backend: {
                  service: { name: name, port: { number: e.port } },
                },
              }],
            },
          }],
          // Optional TLS per endpoint:
          // add tlsSecretName to an endpoint to enable TLS for that host
          tls: (
            if std.objectHas(e, 'tlsSecretName') then
              [{ secretName: e.tlsSecretName, hosts: [ e.host ] }]
            else null
          ),
        },
      }
      for e in endpoints
      if !std.objectHas(e, 'type') || std.toLower(e.type) == 'ingress'
    ];

    local routes = [
      {
        apiVersion: 'gateway.networking.k8s.io/v1',
        kind: 'HTTPRoute',
        metadata: {
          name: name + '-' + e.name,
          labels: { 'app.kubernetes.io/name': name },
        },
        spec: {
          parentRefs: [{ name: gatewayName }],
          hostnames: [ e.host ],
          rules: [{
            matches: [{ path: { type: 'PathPrefix', value: e.path } }],
            backendRefs: [{ name: name, port: e.port }],
          }],
        },
      }
      for e in endpoints
      if std.objectHas(e, 'type') && std.toLower(e.type) == 'managedapi'
    ];

    // Return as a flat list of k8s objects
    [deployment, service] + ingresses + routes,
}