storage

type Artifactory struct {
	// contains filtered or unexported fields
}

type ArtifactoryError struct {
	Status  int    `json:"status"`
	Message string `json:"message"`
}

type ArtifactoryFile struct {
	URI    string `json:"uri"`
	Folder bool   `json:"folder"`
}

type ArtifactoryList struct {
	Files []ArtifactoryFile `json:"files"`
}

type ArtifactoryOptions struct {
	// How long to cache list responses.  Zero means no cache.  Manifests are
	// currently cached indefinitely since they do not change.
	ListCacheDuration time.Duration
	Logger            slog.Logger
	Repo              string
	Token             string
	URI               string
}

type ArtifactoryResponse struct {
	Errors []ArtifactoryError `json:"errors"`
}

type AssetType string

type Local struct {
	// contains filtered or unexported fields
}

type Options struct {
	Artifactory string
	ExtDir      string
	Repo        string
	Logger      slog.Logger
}

type PropertyType string

type Storage interface {
	// AddExtension adds the provided VSIX into storage and returns the location
	// for verification purposes.
	AddExtension(ctx context.Context, manifest *VSIXManifest, vsix []byte) (string, error)
	// FileServer provides a handler for fetching extension repository files from
	// a client.
	FileServer() http.Handler
	// Manifest returns the manifest bytes for the provided extension.  The
	// extension asset itself (the VSIX) will be included on the manifest even if
	// it does not exist on the manifest on disk.
	Manifest(ctx context.Context, publisher, name, version string) (*VSIXManifest, error)
	// RemoveExtension removes the provided version of the extension.  It errors
	// if the provided version does not exist or if removing it fails.  If version
	// is blank all versions of that extension will be removed.
	RemoveExtension(ctx context.Context, publisher, name, version string) error
	// Versions returns the available versions of the provided extension in sorted
	// order.  If the extension does not exits it returns an error.
	Versions(ctx context.Context, publisher, name string) ([]string, error)
	// WalkExtensions applies a function over every extension.  The extension
	// points to the latest version and the versions slice includes all the
	// versions in sorted order including the latest version (which will be in
	// [0]).  If the function returns an error the error is immediately returned
	// which aborts the walk.
	WalkExtensions(ctx context.Context, fn func(manifest *VSIXManifest, versions []string) error) error
}

type VSIXAsset struct {
	Type        AssetType `xml:",attr"`
	Path        string    `xml:",attr"`
	Addressable string    `xml:",attr"`
}

type VSIXAssets struct {
	Asset []VSIXAsset
}

type VSIXIdentity struct {
	// ID correlates to ExtensionName, *not* ExtensionID.
	ID             string `xml:"Id,attr"`
	Version        string `xml:",attr"`
	Publisher      string `xml:",attr"`
	TargetPlatform string `xml:",attr"`
}

type VSIXManifest struct {
	Metadata     VSIXMetadata
	Installation struct {
		InstallationTarget struct {
			ID string `xml:"Id,attr"`
		}
	}
	Dependencies []string
	Assets       VSIXAssets
}

type VSIXMetadata struct {
	Description  string
	DisplayName  string
	Identity     VSIXIdentity
	Tags         string
	GalleryFlags string
	License      string
	Icon         string
	Properties   VSIXProperties
	Categories   string
}

type VSIXPackageJSON struct {
	Browser string `json:"browser"`
}

type VSIXProperties struct {
	Property []VSIXProperty
}

type VSIXProperty struct {
	ID    PropertyType `xml:"Id,attr"`
	Value string       `xml:",attr"`
}