Module veröffentlichen

Teile wiederverwendbaren Code im Wippy Hub.

Voraussetzungen

1. Erstelle ein Konto auf hub.wippy.ai
2. Erstelle eine Organisation oder tritt einer bei
3. Registriere deinen Modulnamen unter deiner Organisation

Modulstruktur

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

wippy.yaml

Modul-Manifest:

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

Eintragsdefinitionen

Einträge werden in _index.yaml definiert:

version: "1.0"
namespace: acme.http

entries:
  - name: definition
    kind: ns.definition
    meta:
      title: HTTP Utilities
      description: Helpers for HTTP operations

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

Abhängigkeiten

Deklariere Abhängigkeiten zu anderen Modulen:

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

Versions-Constraints:

Anforderungen

Definiere Konfigurationen, die Konsumenten bereitstellen müssen:

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

Targets geben an, wo der Wert eingefügt wird:

• entry - Vollständige Eintrags-ID, die konfiguriert werden soll
• path - JSONPath für die Werteinfügung

Konsumenten konfigurieren über Override. Das -o-Flag erwartet ein Tripel namespace:entry:field=value:

wippy run -o acme.http:client:meta.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: Perform GET request
    - name: post
      description: Perform POST request

- 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. Authentifizierung

wippy auth login

2. Vorbereitung

wippy init
wippy update
wippy lint

3. Validierung

wippy publish --dry-run

4. Veröffentlichung

wippy publish --version 1.0.0

Mit Release Notes:

wippy publish --version 1.0.0 --release-notes "Initial release"

Zusätzliche Flags

Statische Dateien einbetten

Module mit fs.directory-Einträgen (statische Assets, Templates, öffentliche Dateien) müssen --embed verwenden, um sie in das veröffentlichte Paket aufzunehmen. Ohne dieses Flag werden fs.directory-Einträge ausgeschlossen.

wippy publish --version 1.0.0 --embed app:public_files
wippy publish --version 1.0.0 --embed app:assets,app:templates

Das --embed-Flag akzeptiert Eintrags-IDs oder Namen, die mit fs.directory-Einträgen übereinstimmen. Dasselbe Flag ist auch für wippy pack verfügbar.

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:client:meta.endpoint=https://my.api.com

Oder in .wippy.yaml:

override:
  acme.http:client:meta.endpoint: "https://my.api.com"

Im eigenen Code importieren

# your 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 with TTL
license: MIT
keywords:
  - cache
  - memory

src/_index.yaml:

version: "1.0"
namespace: acme.cache

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

  - name: max_size
    kind: ns.requirement
    meta:
      description: Maximum cache entries
    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