@backstage/plugin-scaffolder-backend 0.16.0 → 0.16.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @backstage/plugin-scaffolder-backend
 
+## 0.16.1
+
+### Patch Changes
+
+- Fix for the previous release with missing type declarations.
+- Updated dependencies
+  - @backstage/backend-common@0.10.9
+  - @backstage/catalog-client@0.7.1
+  - @backstage/catalog-model@0.10.1
+  - @backstage/config@0.1.15
+  - @backstage/errors@0.2.2
+  - @backstage/integration@0.7.4
+  - @backstage/types@0.1.3
+  - @backstage/plugin-catalog-backend@0.21.5
+  - @backstage/plugin-scaffolder-backend-module-cookiecutter@0.2.1
+  - @backstage/plugin-scaffolder-common@0.2.1
+
 ## 0.16.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -0,0 +1,577 @@
+/// <reference types="node" />
+import { ScmIntegrations, ScmIntegrationRegistry, GithubCredentialsProvider } from '@backstage/integration';
+import { CatalogApi } from '@backstage/catalog-client';
+import { Logger } from 'winston';
+import { Writable } from 'stream';
+import { JsonValue, JsonObject } from '@backstage/types';
+import { Schema } from 'jsonschema';
+import { TaskSpec, TemplateMetadata } from '@backstage/plugin-scaffolder-common';
+export { TaskSpec, TaskSpecV1beta2, TaskSpecV1beta3, TemplateMetadata } from '@backstage/plugin-scaffolder-common';
+import { Entity, LocationSpec } from '@backstage/catalog-model';
+import { UrlReader, ContainerRunner, PluginDatabaseManager } from '@backstage/backend-common';
+import { Config } from '@backstage/config';
+import { createPullRequest } from 'octokit-plugin-create-pull-request';
+import { Octokit } from 'octokit';
+export { createFetchCookiecutterAction } from '@backstage/plugin-scaffolder-backend-module-cookiecutter';
+import { SpawnOptionsWithoutStdio } from 'child_process';
+import { Knex } from 'knex';
+import express from 'express';
+import { CatalogProcessor, CatalogProcessorEmit } from '@backstage/plugin-catalog-backend';
+
+declare function createCatalogRegisterAction(options: {
+    catalogClient: CatalogApi;
+    integrations: ScmIntegrations;
+}): TemplateAction<{
+    catalogInfoUrl: string;
+    optional?: boolean | undefined;
+} | {
+    repoContentsUrl: string;
+    catalogInfoPath?: string | undefined;
+    optional?: boolean | undefined;
+}>;
+
+declare function createCatalogWriteAction(): TemplateAction<{
+    filePath?: string | undefined;
+    entity: Entity;
+}>;
+
+declare type TemplateFilter = (...args: JsonValue[]) => JsonValue | undefined;
+
+/**
+ * Status
+ *
+ * @public
+ */
+declare type Status = 'open' | 'processing' | 'failed' | 'cancelled' | 'completed';
+/**
+ * CompletedTaskState
+ *
+ * @public
+ */
+declare type CompletedTaskState = 'failed' | 'completed';
+/**
+ * SerializedTask
+ *
+ * @public
+ */
+declare type SerializedTask = {
+    id: string;
+    spec: TaskSpec;
+    status: Status;
+    createdAt: string;
+    lastHeartbeatAt?: string;
+    secrets?: TaskSecrets;
+};
+/**
+ * TaskEventType
+ *
+ * @public
+ */
+declare type TaskEventType = 'completion' | 'log';
+/**
+ * SerializedTaskEvent
+ *
+ * @public
+ */
+declare type SerializedTaskEvent = {
+    id: number;
+    taskId: string;
+    body: JsonObject;
+    type: TaskEventType;
+    createdAt: string;
+};
+/**
+ * TaskSecrets
+ *
+ * @public
+ */
+declare type TaskSecrets = Record<string, string> & {
+    backstageToken?: string;
+};
+/**
+ * DispatchResult
+ *
+ * @public
+ */
+declare type DispatchResult = {
+    taskId: string;
+};
+/**
+ * Task
+ *
+ * @public
+ */
+interface TaskContext {
+    spec: TaskSpec;
+    secrets?: TaskSecrets;
+    done: boolean;
+    emitLog(message: string, metadata?: JsonValue): Promise<void>;
+    complete(result: CompletedTaskState, metadata?: JsonValue): Promise<void>;
+    getWorkspaceName(): Promise<string>;
+}
+/**
+ * TaskBroker
+ *
+ * @public
+ */
+interface TaskBroker {
+    claim(): Promise<TaskContext>;
+    dispatch(spec: TaskSpec, secrets?: TaskSecrets): Promise<DispatchResult>;
+    vacuumTasks(timeoutS: {
+        timeoutS: number;
+    }): Promise<void>;
+    observe(options: {
+        taskId: string;
+        after: number | undefined;
+    }, callback: (error: Error | undefined, result: {
+        events: SerializedTaskEvent[];
+    }) => void): {
+        unsubscribe: () => void;
+    };
+    get(taskId: string): Promise<SerializedTask>;
+}
+/**
+ * TaskStoreEmitOptions
+ *
+ * @public
+ */
+declare type TaskStoreEmitOptions = {
+    taskId: string;
+    body: JsonObject;
+};
+/**
+ * TaskStoreListEventsOptions
+ *
+ * @public
+ */
+declare type TaskStoreListEventsOptions = {
+    taskId: string;
+    after?: number | undefined;
+};
+/**
+ * TaskStore
+ *
+ * @public
+ */
+interface TaskStore {
+    createTask(task: TaskSpec, secrets?: TaskSecrets): Promise<{
+        taskId: string;
+    }>;
+    getTask(taskId: string): Promise<SerializedTask>;
+    claimTask(): Promise<SerializedTask | undefined>;
+    completeTask(options: {
+        taskId: string;
+        status: Status;
+        eventBody: JsonObject;
+    }): Promise<void>;
+    heartbeatTask(taskId: string): Promise<void>;
+    listStaleTasks(options: {
+        timeoutS: number;
+    }): Promise<{
+        tasks: {
+            taskId: string;
+        }[];
+    }>;
+    emitLogEvent({ taskId, body }: TaskStoreEmitOptions): Promise<void>;
+    listEvents({ taskId, after, }: TaskStoreListEventsOptions): Promise<{
+        events: SerializedTaskEvent[];
+    }>;
+}
+
+declare type ActionContext<Input extends JsonObject> = {
+    /**
+     * Base URL for the location of the task spec, typically the url of the source entity file.
+     */
+    baseUrl?: string;
+    logger: Logger;
+    logStream: Writable;
+    secrets?: TaskSecrets;
+    workspacePath: string;
+    input: Input;
+    output(name: string, value: JsonValue): void;
+    /**
+     * Creates a temporary directory for use by the action, which is then cleaned up automatically.
+     */
+    createTemporaryDirectory(): Promise<string>;
+    metadata?: TemplateMetadata;
+};
+declare type TemplateAction<Input extends JsonObject> = {
+    id: string;
+    description?: string;
+    schema?: {
+        input?: Schema;
+        output?: Schema;
+    };
+    handler: (ctx: ActionContext<Input>) => Promise<void>;
+};
+
+declare const createBuiltinActions: (options: {
+    reader: UrlReader;
+    integrations: ScmIntegrations;
+    catalogClient: CatalogApi;
+    containerRunner?: ContainerRunner;
+    config: Config;
+    additionalTemplateFilters?: Record<string, TemplateFilter>;
+}) => TemplateAction<JsonObject>[];
+
+/**
+ * This task is useful for local development and testing of both the scaffolder
+ * and scaffolder templates.
+ */
+declare function createDebugLogAction(): TemplateAction<{
+    message?: string | undefined;
+    listWorkspace?: boolean | undefined;
+}>;
+
+declare function createFetchPlainAction(options: {
+    reader: UrlReader;
+    integrations: ScmIntegrations;
+}): TemplateAction<{
+    url: string;
+    targetPath?: string | undefined;
+}>;
+
+declare function createFetchTemplateAction(options: {
+    reader: UrlReader;
+    integrations: ScmIntegrations;
+    additionalTemplateFilters?: Record<string, TemplateFilter>;
+}): TemplateAction<{
+    url: string;
+    targetPath?: string | undefined;
+    values: any;
+    templateFileExtension?: string | boolean | undefined;
+    copyWithoutRender?: string[] | undefined;
+    cookiecutterCompat?: boolean | undefined;
+}>;
+
+declare function fetchContents({ reader, integrations, baseUrl, fetchUrl, outputPath, }: {
+    reader: UrlReader;
+    integrations: ScmIntegrations;
+    baseUrl?: string;
+    fetchUrl?: JsonValue;
+    outputPath: string;
+}): Promise<void>;
+
+declare const createFilesystemDeleteAction: () => TemplateAction<{
+    files: string[];
+}>;
+
+declare const createFilesystemRenameAction: () => TemplateAction<{
+    files: Array<{
+        from: string;
+        to: string;
+        overwrite?: boolean;
+    }>;
+}>;
+
+declare function createPublishAzureAction(options: {
+    integrations: ScmIntegrationRegistry;
+    config: Config;
+}): TemplateAction<{
+    repoUrl: string;
+    description?: string | undefined;
+    defaultBranch?: string | undefined;
+    sourcePath?: string | undefined;
+    token?: string | undefined;
+}>;
+
+declare function createPublishBitbucketAction(options: {
+    integrations: ScmIntegrationRegistry;
+    config: Config;
+}): TemplateAction<{
+    repoUrl: string;
+    description?: string | undefined;
+    defaultBranch?: string | undefined;
+    repoVisibility?: "private" | "public" | undefined;
+    sourcePath?: string | undefined;
+    enableLFS?: boolean | undefined;
+    token?: string | undefined;
+}>;
+
+/**
+ * This task is useful for local development and testing of both the scaffolder
+ * and scaffolder templates.
+ *
+ * This action is not installed by default and should not be installed in
+ * production, as it writes the files to the local filesystem of the scaffolder.
+ */
+declare function createPublishFileAction(): TemplateAction<{
+    path: string;
+}>;
+
+declare function createPublishGithubAction(options: {
+    integrations: ScmIntegrationRegistry;
+    config: Config;
+    githubCredentialsProvider?: GithubCredentialsProvider;
+}): TemplateAction<{
+    repoUrl: string;
+    description?: string | undefined;
+    access?: string | undefined;
+    defaultBranch?: string | undefined;
+    sourcePath?: string | undefined;
+    requireCodeOwnerReviews?: boolean | undefined;
+    repoVisibility?: "internal" | "private" | "public" | undefined;
+    collaborators?: {
+        username: string;
+        access: 'pull' | 'push' | 'admin' | 'maintain' | 'triage';
+    }[] | undefined;
+    token?: string | undefined;
+    topics?: string[] | undefined;
+}>;
+
+declare type CreatePullRequestResponse = {
+    data: {
+        html_url: string;
+    };
+};
+interface PullRequestCreator {
+    createPullRequest(options: createPullRequest.Options): Promise<CreatePullRequestResponse | null>;
+}
+declare type ClientFactoryInput = {
+    integrations: ScmIntegrationRegistry;
+    githubCredentialsProvider?: GithubCredentialsProvider;
+    host: string;
+    owner: string;
+    repo: string;
+    token?: string;
+};
+interface CreateGithubPullRequestActionOptions {
+    integrations: ScmIntegrationRegistry;
+    githubCredentialsProvider?: GithubCredentialsProvider;
+    clientFactory?: (input: ClientFactoryInput) => Promise<PullRequestCreator>;
+}
+declare const createPublishGithubPullRequestAction: ({ integrations, githubCredentialsProvider, clientFactory, }: CreateGithubPullRequestActionOptions) => TemplateAction<{
+    title: string;
+    branchName: string;
+    description: string;
+    repoUrl: string;
+    targetPath?: string | undefined;
+    sourcePath?: string | undefined;
+    token?: string | undefined;
+}>;
+
+declare function createPublishGitlabAction(options: {
+    integrations: ScmIntegrationRegistry;
+    config: Config;
+}): TemplateAction<{
+    repoUrl: string;
+    defaultBranch?: string | undefined;
+    repoVisibility?: "internal" | "private" | "public" | undefined;
+    sourcePath?: string | undefined;
+    token?: string | undefined;
+}>;
+
+declare const createPublishGitlabMergeRequestAction: (options: {
+    integrations: ScmIntegrationRegistry;
+}) => TemplateAction<{
+    projectid: string;
+    repoUrl: string;
+    title: string;
+    description: string;
+    branchName: string;
+    targetPath: string;
+    token?: string | undefined;
+}>;
+
+declare function createGithubActionsDispatchAction(options: {
+    integrations: ScmIntegrations;
+    githubCredentialsProvider?: GithubCredentialsProvider;
+}): TemplateAction<{
+    repoUrl: string;
+    workflowId: string;
+    branchOrTagName: string;
+    workflowInputs?: {
+        [key: string]: string;
+    } | undefined;
+    token?: string | undefined;
+}>;
+
+declare function createGithubWebhookAction(options: {
+    integrations: ScmIntegrationRegistry;
+    defaultWebhookSecret?: string;
+    githubCredentialsProvider?: GithubCredentialsProvider;
+}): TemplateAction<{
+    repoUrl: string;
+    webhookUrl: string;
+    webhookSecret?: string | undefined;
+    events?: string[] | undefined;
+    active?: boolean | undefined;
+    contentType?: "form" | "json" | undefined;
+    insecureSsl?: boolean | undefined;
+    token?: string | undefined;
+}>;
+
+declare type OctokitIntegration = {
+    client: Octokit;
+    token: string;
+    owner: string;
+    repo: string;
+};
+/**
+ * OctokitProvider provides Octokit client based on ScmIntegrationsRegistry configuration.
+ * OctokitProvider supports GitHub credentials caching out of the box.
+ */
+declare class OctokitProvider {
+    private readonly integrations;
+    private readonly githubCredentialsProvider;
+    constructor(integrations: ScmIntegrationRegistry, githubCredentialsProvider?: GithubCredentialsProvider);
+    /**
+     * gets standard Octokit client based on repository URL.
+     *
+     * @param repoUrl - Repository URL
+     */
+    getOctokit(repoUrl: string, options?: {
+        token?: string;
+    }): Promise<OctokitIntegration>;
+}
+
+declare type RunCommandOptions = {
+    /** command to run */
+    command: string;
+    /** arguments to pass the command */
+    args: string[];
+    /** options to pass to spawn */
+    options?: SpawnOptionsWithoutStdio;
+    /** stream to capture stdout and stderr output */
+    logStream?: Writable;
+};
+/**
+ * Run a command in a sub-process, normally a shell command.
+ */
+declare const runCommand: ({ command, args, logStream, options, }: RunCommandOptions) => Promise<void>;
+
+declare class TemplateActionRegistry {
+    private readonly actions;
+    register<TInput extends JsonObject>(action: TemplateAction<TInput>): void;
+    get(actionId: string): TemplateAction<JsonObject>;
+    list(): TemplateAction<JsonObject>[];
+}
+
+declare const createTemplateAction: <TInput extends JsonObject>(templateAction: TemplateAction<TInput>) => TemplateAction<TInput>;
+
+/**
+ * DatabaseTaskStore
+ *
+ * @public
+ */
+declare type DatabaseTaskStoreOptions = {
+    database: Knex;
+};
+/**
+ * DatabaseTaskStore
+ *
+ * @public
+ */
+declare class DatabaseTaskStore implements TaskStore {
+    private readonly db;
+    static create(options: DatabaseTaskStoreOptions): Promise<DatabaseTaskStore>;
+    constructor(options: DatabaseTaskStoreOptions);
+    getTask(taskId: string): Promise<SerializedTask>;
+    createTask(spec: TaskSpec, secrets?: TaskSecrets): Promise<{
+        taskId: string;
+    }>;
+    claimTask(): Promise<SerializedTask | undefined>;
+    heartbeatTask(taskId: string): Promise<void>;
+    listStaleTasks({ timeoutS }: {
+        timeoutS: number;
+    }): Promise<{
+        tasks: {
+            taskId: string;
+        }[];
+    }>;
+    completeTask({ taskId, status, eventBody, }: {
+        taskId: string;
+        status: Status;
+        eventBody: JsonObject;
+    }): Promise<void>;
+    emitLogEvent({ taskId, body }: TaskStoreEmitOptions): Promise<void>;
+    listEvents({ taskId, after, }: TaskStoreListEventsOptions): Promise<{
+        events: SerializedTaskEvent[];
+    }>;
+}
+
+/**
+ * TaskManager
+ *
+ * @public
+ */
+declare class TaskManager implements TaskContext {
+    private readonly state;
+    private readonly storage;
+    private readonly logger;
+    private isDone;
+    private heartbeatTimeoutId?;
+    static create(state: TaskState, storage: TaskStore, logger: Logger): TaskManager;
+    private constructor();
+    get spec(): TaskSpec;
+    get secrets(): TaskSecrets | undefined;
+    getWorkspaceName(): Promise<string>;
+    get done(): boolean;
+    emitLog(message: string, metadata?: JsonObject): Promise<void>;
+    complete(result: CompletedTaskState, metadata?: JsonObject): Promise<void>;
+    private startTimeout;
+}
+/**
+ * TaskState
+ *
+ * @public
+ */
+interface TaskState {
+    spec: TaskSpec;
+    taskId: string;
+    secrets?: TaskSecrets;
+}
+
+/**
+ * CreateWorkerOptions
+ *
+ * @public
+ */
+declare type CreateWorkerOptions = {
+    taskBroker: TaskBroker;
+    actionRegistry: TemplateActionRegistry;
+    integrations: ScmIntegrations;
+    workingDirectory: string;
+    logger: Logger;
+    additionalTemplateFilters?: Record<string, TemplateFilter>;
+};
+/**
+ * TaskWorker
+ *
+ * @public
+ */
+declare class TaskWorker {
+    private readonly options;
+    private constructor();
+    static create(options: CreateWorkerOptions): Promise<TaskWorker>;
+    start(): void;
+    runOneTask(task: TaskContext): Promise<void>;
+}
+
+/**
+ * RouterOptions
+ *
+ * @public
+ */
+interface RouterOptions {
+    logger: Logger;
+    config: Config;
+    reader: UrlReader;
+    database: PluginDatabaseManager;
+    catalogClient: CatalogApi;
+    actions?: TemplateAction<any>[];
+    taskWorkers?: number;
+    containerRunner?: ContainerRunner;
+    taskBroker?: TaskBroker;
+    additionalTemplateFilters?: Record<string, TemplateFilter>;
+}
+declare function createRouter(options: RouterOptions): Promise<express.Router>;
+
+/** @public */
+declare class ScaffolderEntitiesProcessor implements CatalogProcessor {
+    private readonly validators;
+    validateEntityKind(entity: Entity): Promise<boolean>;
+    postProcessEntity(entity: Entity, _location: LocationSpec, emit: CatalogProcessorEmit): Promise<Entity>;
+}
+
+export { ActionContext, CompletedTaskState, CreateWorkerOptions, DatabaseTaskStore, DispatchResult, OctokitProvider, RouterOptions, ScaffolderEntitiesProcessor, SerializedTask, SerializedTaskEvent, Status, TaskBroker, TaskContext, TaskEventType, TaskManager, TaskSecrets, TaskState, TaskStore, TaskStoreEmitOptions, TaskStoreListEventsOptions, TaskWorker, TemplateAction, TemplateActionRegistry, TemplateFilter, createBuiltinActions, createCatalogRegisterAction, createCatalogWriteAction, createDebugLogAction, createFetchPlainAction, createFetchTemplateAction, createFilesystemDeleteAction, createFilesystemRenameAction, createGithubActionsDispatchAction, createGithubWebhookAction, createPublishAzureAction, createPublishBitbucketAction, createPublishFileAction, createPublishGithubAction, createPublishGithubPullRequestAction, createPublishGitlabAction, createPublishGitlabMergeRequestAction, createRouter, createTemplateAction, fetchContents, runCommand };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@backstage/plugin-scaffolder-backend",
   "description": "The Backstage backend plugin that helps you create new things",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "main": "dist/index.cjs.js",
   "types": "dist/index.d.ts",
   "license": "Apache-2.0",
@@ -34,16 +34,16 @@
     "build:assets": "node scripts/build-nunjucks.js"
   },
   "dependencies": {
-    "@backstage/backend-common": "^0.10.8",
-    "@backstage/catalog-client": "^0.7.0",
-    "@backstage/catalog-model": "^0.10.0",
-    "@backstage/config": "^0.1.14",
-    "@backstage/errors": "^0.2.1",
-    "@backstage/integration": "^0.7.3",
-    "@backstage/plugin-catalog-backend": "^0.21.4",
-    "@backstage/plugin-scaffolder-backend-module-cookiecutter": "^0.2.0",
-    "@backstage/plugin-scaffolder-common": "^0.2.0",
-    "@backstage/types": "^0.1.2",
+    "@backstage/backend-common": "^0.10.9",
+    "@backstage/catalog-client": "^0.7.1",
+    "@backstage/catalog-model": "^0.10.1",
+    "@backstage/config": "^0.1.15",
+    "@backstage/errors": "^0.2.2",
+    "@backstage/integration": "^0.7.4",
+    "@backstage/plugin-catalog-backend": "^0.21.5",
+    "@backstage/plugin-scaffolder-backend-module-cookiecutter": "^0.2.1",
+    "@backstage/plugin-scaffolder-common": "^0.2.1",
+    "@backstage/types": "^0.1.3",
     "@gitbeaker/core": "^34.6.0",
     "@gitbeaker/node": "^35.1.0",
     "@octokit/webhooks": "^9.14.1",
@@ -97,5 +97,5 @@
     "assets"
   ],
   "configSchema": "config.d.ts",
-  "gitHead": "4805c3d13ce9bfc369e53c271b1b95e722b3b4dc"
+  "gitHead": "e244b348c473700e7d5e5fbcef38bd9f9fd1d0ba"
 }