Module veröffentlichen

Wiederverwendbaren Code auf dem Wippy Hub teilen.

Voraussetzungen

1. Konto auf hub.wippy.ai erstellen
2. Organisation erstellen oder einer beitreten
3. Modulnamen unter Ihrer Organisation registrieren

Modulstruktur

mymodule/
├── wippy.yaml      # Modul-Manifest
├── src/
│   ├── _index.yaml # Entry-Definitionen
│   └── *.lua       # Quelldateien
└── README.md       # Dokumentation (optional)

wippy.yaml

Modul-Manifest:

organization: acme
module: http-utils
description: HTTP-Utilities und Helfer
license: MIT
repository: https://github.com/acme/http-utils
homepage: https://acme.dev
keywords:
  - http
  - utilities

Entry-Definitionen

Einträge werden in _index.yaml definiert:

version: "1.0"
namespace: acme.http

entries:
  - name: definition
    kind: ns.definition
    meta:
      title: HTTP-Utilities
      description: Helfer für HTTP-Operationen

  - name: client
    kind: library.lua
    source: file://client.lua
    modules:
      - http_client
      - json

Abhängigkeiten

Abhängigkeiten von anderen Modulen deklarieren:

entries:
  - name: __dependency.wippy.test
    kind: ns.dependency
    meta:
      description: Test-Framework
    component: wippy/test
    version: ">=0.3.0"

Versionsbeschränkungen:

Anforderungen

Konfiguration definieren, die Konsumenten bereitstellen müssen:

entries:
  - name: api_endpoint
    kind: ns.requirement
    meta:
      description: API-Endpunkt-URL
    targets:
      - entry: acme.http:client
        path: ".meta.endpoint"
    default: "https://api.example.com"

Targets spezifizieren, wo der Wert injiziert wird:

• entry - Vollständige Entry-ID zum Konfigurieren
• path - JSONPath für Wert-Injektion

Konsumenten konfigurieren über Override:

wippy run -o acme.http:api_endpoint=https://custom.api.com

Imports

Andere Einträge referenzieren:

- name: handler
  kind: function.lua
  source: file://handler.lua
  modules:
    - json
  imports:
    client: acme.http:client           # Gleicher Namespace
    utils: acme.utils:helpers          # Anderer Namespace
    base_registry: :registry           # Eingebaut

In Lua:

local client = require("client")
local utils = require("utils")

Contracts

Öffentliche Schnittstellen definieren:

- name: http_contract
  kind: contract.definition
  meta:
    name: HTTP Client Contract
  methods:
    - name: get
      description: GET-Anfrage ausführen
    - name: post
      description: POST-Anfrage ausführen

- name: http_contract_binding
  kind: contract.binding
  contracts:
    - contract: acme.http:http_contract
      methods:
        get: acme.http:get_handler
        post: acme.http:post_handler

Veröffentlichungs-Workflow

1. Authentifizieren

wippy auth login

2. Vorbereiten

wippy init
wippy update
wippy lint

3. Validieren

wippy publish --dry-run

4. Veröffentlichen

wippy publish --version 1.0.0

Mit Release-Notizen:

wippy publish --version 1.0.0 --release-notes "Erste Veröffentlichung"

Veröffentlichte Module verwenden

Abhängigkeit hinzufügen

wippy add acme/http-utils
wippy add acme/http-utils@1.0.0
wippy install

Anforderungen konfigurieren

Werte zur Laufzeit überschreiben:

wippy run -o acme.http:api_endpoint=https://my.api.com

Oder in .wippy.yaml:

override:
  acme.http:api_endpoint: "https://my.api.com"

In Ihrem Code importieren

# Ihr src/_index.yaml
entries:
  - name: __dependency.acme.http
    kind: ns.dependency
    component: acme/http-utils
    version: ">=1.0.0"

  - name: my_handler
    kind: function.lua
    source: file://handler.lua
    imports:
      http: acme.http:client

Vollständiges Beispiel

wippy.yaml:

organization: acme
module: cache
description: In-Memory-Caching mit TTL
license: MIT
keywords:
  - cache
  - memory

src/_index.yaml:

version: "1.0"
namespace: acme.cache

entries:
  - name: definition
    kind: ns.definition
    meta:
      title: Cache-Modul

  - name: max_size
    kind: ns.requirement
    meta:
      description: Maximale Cache-Einträge
    targets:
      - entry: acme.cache:cache
        path: ".meta.max_size"
    default: "1000"

  - name: cache
    kind: library.lua
    meta:
      max_size: 1000
    source: file://cache.lua
    modules:
      - time

src/cache.lua:

local time = require("time")

local cache = {}
local store = {}
local max_size = 1000

function cache.set(key, value, ttl)
    if #store >= max_size then
        cache.evict_oldest()
    end
    store[key] = {
        value = value,
        expires = ttl and (time.now():unix() + ttl) or nil
    }
end

function cache.get(key)
    local entry = store[key]
    if not entry then return nil end
    if entry.expires and time.now():unix() > entry.expires then
        store[key] = nil
        return nil
    end
    return entry.value
end

return cache

Veröffentlichen:

wippy init && wippy update && wippy lint
wippy publish --version 1.0.0

Siehe auch

• CLI-Referenz
• Entry-Typen
• Konfiguration