@goodfellow-cms/gitlab 0.5.0 → 0.7.0

package/README.md

@@ -8,7 +8,7 @@ import { gitlab } from "@goodfellow-cms/gitlab";
 export default defineConfig({ blocks, backend: gitlab({ project: "your-name/your-site" }) });
 ```
 
-[Goodfellow](https://github.com/goodfellow-cms/goodfellow-cms) is a website builder for people who aren't developers, with no server or database: pages are files in your own GitHub or GitLab repository, edited in a visual editor built on [Puck](https://puckeditor.com). To start a new site, run `npm create goodfellow@latest my-site`. See the [documentation](https://goodfellow-cms.github.io/goodfellow-cms/) for everything else.
+[Goodfellow](https://github.com/goodfellow-cms/goodfellow-cms) is a website builder for people who aren't developers, with no server or database: pages are files in your own GitHub, GitLab or Bitbucket repository, edited in a visual editor built on [Puck](https://puckeditor.com). To start a new site, run `npm create goodfellow@latest my-site`. See the [documentation](https://goodfellow-cms.github.io/goodfellow-cms/) for everything else.
 
 More in the docs: [Hosts and business sites](https://goodfellow-cms.github.io/goodfellow-cms/docs/hosts).
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ConnectDomainOptions, DeployStatus, DnsRecord, FileChange, FileVersion, GitBackend, GitHost, GitUser, HistoryOptions, PagesDomains, RepositoryVisibility, RevisionFiles, ScheduledBuilds, SetupHost, SiteDrafts, SiteEditors, SiteUpdates, StorageLike, WriteOptions } from "@goodfellow-cms/core";
+import { ConnectDomainOptions, DeployStatus, DnsRecord, FileChange, FileVersion, GitBackend, GitHost, GitUser, HistoryOptions, PagesDomains, PluginTasks, RepositoryVisibility, RevisionFiles, ScheduledBuilds, SetupHost, SiteDrafts, SiteEditors, SiteUpdates, StorageLike, WriteOptions } from "@goodfellow-cms/core";
 //#region src/api.d.ts
 interface ApiOptions {
   /** The API root, such as `https://gitlab.com/api/v4`. */
@@ -12,6 +12,15 @@ interface ApiOptions {
   fetch: typeof fetch;
 }
 //#endregion
+//#region src/tasks.d.ts
+interface GitLabTasksOptions {
+  /** How often to look for the answer, and how long to wait for it. */
+  pollMs?: number;
+  timeoutMs?: number;
+  /** Waits between looks; tests pass one that doesn't. */
+  wait?: (ms: number) => Promise<void>;
+}
+//#endregion
 //#region src/backend.d.ts
 interface GitLabBackendOptions {
   api: ApiOptions;
@@ -26,6 +35,8 @@ interface GitLabBackendOptions {
   };
   /** The commit reads see until `revision()` is next called, as a full-stack site's server reads what a browser loaded. */
   revision?: string;
+  /** How plugins' tasks wait for their answers; tests pass short waits. */
+  tasks?: GitLabTasksOptions;
   /** The project holds only the site's content, with its code in a project of its own (`GitBackend.contentOnly`). */
   contentOnly?: boolean;
   /** The code project, for a project that holds only content, where the site's updates run. */
@@ -33,6 +44,13 @@ interface GitLabBackendOptions {
     project: string;
     webUrl: string;
   };
+  /** What's read at each commit, shared with the backends of the project's other branches (drafts), since commits never change. */
+  caches?: GitLabCaches;
+}
+/** Path → blob id for the editable files at each commit, and each blob's text, by id. */
+interface GitLabCaches {
+  trees: Map<string, Promise<Map<string, string>>>;
+  blobs: Map<string, Promise<string>>;
 }
 /**
  * The site's files on GitLab. Reads come from the commit `revision()` last
@@ -47,6 +65,7 @@ export declare class GitLabBackend implements GitBackend {
   readonly updates?: SiteUpdates;
   readonly drafts: SiteDrafts;
   readonly scheduledBuilds: ScheduledBuilds;
+  readonly tasks: PluginTasks;
   readonly contentOnly: boolean;
   private readonly options;
   private readonly api;
@@ -54,6 +73,7 @@ export declare class GitLabBackend implements GitBackend {
   private readonly branch;
   private readonly onSignOut;
   private pinned?;
+  private readonly caches;
   private readonly trees;
   private readonly blobs;
   constructor(options: GitLabBackendOptions);
@@ -86,6 +106,8 @@ export declare class GitLabBackend implements GitBackend {
   write(changes: FileChange[], { message, expectedRevision }: WriteOptions): Promise<{
     revision: string;
   }>;
+  /** Lists `revision`'s editable files as `before`'s with `changes` made, keeping the text written. */
+  private carryTree;
   history(path: string, { page, perPage }?: HistoryOptions): Promise<FileVersion[]>;
   readAt(path: string, revision: string): Promise<string | undefined>;
   changedPaths(from: string, to: string): Promise<string[]>;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ConflictError, DomainError, DraftError, EDITABLE_FOLDERS, EditorsError, GitApiError, NIGHTLY_VARIABLE, REBUILD_JOB, ScheduledBuildsError, SetupError, SignInError, UpdatesError, assertContentChanges, branchDrafts, buildStepFor, credentialStorage, encodeBase64Bytes, findBuildCause, findUpdateResult, hostSource } from "@goodfellow-cms/core";
+import { ConflictError, DomainError, DraftError, EDITABLE_FOLDERS, EditorsError, GitApiError, LOCKFILE_JOB, NIGHTLY_VARIABLE, PluginTaskError, REBUILD_JOB, ScheduledBuildsError, SetupError, SignInError, TASK_JOB, TASK_POLL_MS, TASK_RESULT_FILE, TASK_TIMEOUT_MS, UpdatesError, assertContentChanges, branchDrafts, buildStepFor, credentialStorage, encodeBase64Bytes, findBuildCause, findUpdateResult, hostSource, taskRequestProblem, withRateLimits } from "@goodfellow-cms/core";
 //#region src/api.ts
 /** Calls the GitLab API. A 401 refreshes the token once; after that it means the sign-in has expired. */
 async function gitlabRequest(api, path, init = {}) {
@@ -411,6 +411,72 @@ function gitlabScheduledBuilds(api, project, branch, readCi, now = () => /* @__P
 	};
 }
 //#endregion
+//#region src/tasks.ts
+/**
+* Plugins' tasks on GitLab, through the starters' `plugin-task` job: a
+* pipeline started with the request's variables (`GOODFELLOW_TASK_PLUGIN` and
+* the rest), whose job leaves the sealed answer as its artifact, read here.
+* Starting pipelines on the main branch needs Developer access, which
+* editors have once `letEditorsPublish()` lets them publish.
+*/
+function gitlabTasks(api, project, branch, readSetup, options = {}) {
+	const base = `/projects/${encodeURIComponent(project)}`;
+	const wait = options.wait ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+	const supported = async () => (await readSetup().catch(() => void 0) ?? "").includes("$GOODFELLOW_TASK_PLUGIN");
+	return {
+		supported,
+		secretsPlace: async () => ({
+			kind: "gitlab",
+			url: `${api.apiUrl.replace(/\/api\/v4\/?$/, "")}/${project}/-/settings/ci_cd#js-cicd-variables-settings`
+		}),
+		async run(request) {
+			const problem = taskRequestProblem(request);
+			if (problem) throw new PluginTaskError("failed", problem);
+			if (!await supported()) throw new PluginTaskError("missing", "The site's setup files don't run plugins' tasks: .gitlab-ci.yml needs the plugin-task job.");
+			const variable = (key, value) => ({
+				key,
+				variable_type: "env_var",
+				value
+			});
+			let pipeline;
+			try {
+				pipeline = await gitlabJson(api, `${base}/pipeline`, {
+					method: "POST",
+					body: {
+						ref: branch,
+						variables: [
+							variable("GOODFELLOW_TASK_REQUEST", request.id),
+							variable("GOODFELLOW_TASK_PLUGIN", request.plugin),
+							variable("GOODFELLOW_TASK_NAME", request.task),
+							variable("GOODFELLOW_TASK_INPUT", request.input),
+							variable("GOODFELLOW_TASK_KEY", request.key)
+						]
+					}
+				});
+			} catch (error) {
+				if (error instanceof GitApiError && (error.status === 403 || error.status === 401)) throw new PluginTaskError("not-allowed", "Running plugins' tasks needs a sign-in that can publish to the site.");
+				throw error;
+			}
+			const deadline = Date.now() + (options.timeoutMs ?? TASK_TIMEOUT_MS);
+			for (;;) {
+				const job = (await gitlabJson(api, `${base}/pipelines/${pipeline.id}/jobs?per_page=100`)).find((candidate) => candidate.name === TASK_JOB);
+				if (job?.status === "success") {
+					const answer = await gitlabRequest(api, `${base}/jobs/${job.id}/artifacts/${TASK_RESULT_FILE}`, { allow: [404] });
+					if (answer.ok) return await answer.text();
+					throw new PluginTaskError("failed", "The site's build service ran the task but left no answer.");
+				}
+				if (job && [
+					"failed",
+					"canceled",
+					"skipped"
+				].includes(job.status)) throw new PluginTaskError("failed", "The site's build service couldn't run the task.");
+				if (Date.now() >= deadline) throw new PluginTaskError("timeout", "The site's build service didn't answer in time.");
+				await wait(options.pollMs ?? TASK_POLL_MS);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/updates.ts
 const CI_FILE = ".gitlab-ci.yml";
 /** When the nightly schedule the Updates screen adds runs, in UTC, as the GitHub Pages workflow's does. */
@@ -633,13 +699,22 @@ const PAGE_SIZE = 100;
 const GRAPHQL_BATCH = 50;
 /** The color and section codes in GitLab's job logs. */
 const ANSI_CODES = new RegExp(`${String.fromCharCode(27)}\\[[\\d;]*[A-Za-z]`, "g");
+/** Git's id for a file's contents (the SHA-1 of `blob <size>\0` and them), as GitLab's tree lists it. */
+async function gitBlobId(bytes) {
+	const header = new TextEncoder().encode(`blob ${bytes.length}\0`);
+	const data = new Uint8Array(header.length + bytes.length);
+	data.set(header);
+	data.set(bytes, header.length);
+	return [...new Uint8Array(await crypto.subtle.digest("SHA-1", data))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 /**
 * Whether a status says when the site is live. A job that only asks another
-* host to rebuild the site doesn't, and nor does the nightly update where
-* Cloudflare builds the site, which runs on the newest commit too.
+* host to rebuild the site doesn't, and nor do the nightly update and the
+* job that writes the lockfile where Cloudflare builds the site, which run
+* on the newest commit too.
 */
 function builds(status) {
-	return status.name !== REBUILD_JOB && status.name !== "update";
+	return status.name !== REBUILD_JOB && status.name !== "update" && status.name !== LOCKFILE_JOB;
 }
 function listFrom(tree, dir) {
 	const prefix = `${dir}/`;
@@ -658,6 +733,7 @@ var GitLabBackend = class GitLabBackend {
 	updates;
 	drafts;
 	scheduledBuilds;
+	tasks;
 	contentOnly;
 	options;
 	api;
@@ -665,8 +741,9 @@ var GitLabBackend = class GitLabBackend {
 	branch;
 	onSignOut;
 	pinned;
-	trees = /* @__PURE__ */ new Map();
-	blobs = /* @__PURE__ */ new Map();
+	caches;
+	trees;
+	blobs;
 	constructor(options) {
 		this.options = options;
 		this.api = options.api;
@@ -675,6 +752,12 @@ var GitLabBackend = class GitLabBackend {
 		this.user = options.user;
 		this.onSignOut = options.onSignOut;
 		this.pinned = options.revision;
+		this.caches = options.caches ?? {
+			trees: /* @__PURE__ */ new Map(),
+			blobs: /* @__PURE__ */ new Map()
+		};
+		this.trees = this.caches.trees;
+		this.blobs = this.caches.blobs;
 		this.pages = gitlabPages(this.api, options.project);
 		this.editors = gitlabEditors(this.api, options.project, this.branch, this.user.login);
 		this.contentOnly = options.contentOnly === true;
@@ -696,6 +779,7 @@ var GitLabBackend = class GitLabBackend {
 		}
 		this.drafts = branchDrafts(this, this.draftHost());
 		this.scheduledBuilds = gitlabScheduledBuilds(this.api, options.project, this.branch, async () => this.readAt(".gitlab-ci.yml", this.pinned ?? await this.revision()));
+		this.tasks = gitlabTasks(this.api, options.project, this.branch, async () => this.readAt(".gitlab-ci.yml", this.pinned ?? await this.revision()), options.tasks);
 	}
 	async repositoryVisibility() {
 		const { visibility } = await gitlabJson(this.api, `/projects/${this.project}`);
@@ -704,11 +788,40 @@ var GitLabBackend = class GitLabBackend {
 	/** Drafts on branches of the project, with merge requests for review. */
 	draftHost() {
 		const project = `/projects/${this.project}`;
+		const openRequests = (branch) => gitlabJson(this.api, `${project}/merge_requests?${new URLSearchParams({
+			source_branch: branch,
+			state: "opened"
+		})}`);
+		/**
+		* Asks people to review a merge request, by their usernames. GitLab's free
+		* plan takes one reviewer, so where it refuses them all, the first is asked.
+		*/
+		const askReviewers = async (iid, usernames) => {
+			const ids = [];
+			for (const username of usernames) {
+				const [found] = await gitlabJson(this.api, `/users?${new URLSearchParams({ username })}`).catch(() => []);
+				if (found) ids.push(found.id);
+			}
+			for (const reviewerIds of ids.length > 1 ? [ids, ids.slice(0, 1)] : [ids]) {
+				if (reviewerIds.length === 0) return;
+				if ((await gitlabRequest(this.api, `${project}/merge_requests/${iid}`, {
+					method: "PUT",
+					body: { reviewer_ids: reviewerIds },
+					allow: [
+						400,
+						403,
+						404,
+						422
+					]
+				})).ok) return;
+			}
+		};
 		return {
 			liveBranch: this.branch,
 			branchStore: (branch) => new GitLabBackend({
 				...this.options,
-				branch
+				branch,
+				caches: this.caches
 			}),
 			createBranch: async (branch, revision) => {
 				if ((await gitlabRequest(this.api, this.repo(`/branches?${new URLSearchParams({
@@ -740,7 +853,7 @@ var GitLabBackend = class GitLabBackend {
 				});
 				return (await gitlabJson(this.api, this.repo(`/branches?${query}`))).map((found) => found.name).filter((name) => name.startsWith(prefix));
 			},
-			openReview: async ({ branch, title, description }) => {
+			openReview: async ({ branch, title, description, reviewers = [] }) => {
 				const response = await gitlabRequest(this.api, `${project}/merge_requests`, {
 					method: "POST",
 					body: {
@@ -756,15 +869,33 @@ var GitLabBackend = class GitLabBackend {
 						409
 					]
 				});
-				if (response.ok) return { url: (await response.json()).web_url };
-				if (response.status !== 409) throw new DraftError("no-reviews", "This sign-in can't open merge requests on the site's project.");
+				let review;
+				if (response.ok) review = await response.json();
+				else if (response.status !== 409) throw new DraftError("no-reviews", "This sign-in can't open merge requests on the site's project.");
+				else {
+					[review] = await openRequests(branch);
+					if (!review) throw new GitApiError(409, "GitLab couldn't open the merge request.");
+				}
+				await askReviewers(review.iid, reviewers);
+				return { url: review.web_url };
+			},
+			listReviews: async (prefix) => {
 				const query = new URLSearchParams({
-					source_branch: branch,
-					state: "opened"
+					state: "opened",
+					per_page: "100"
+				});
+				return (await gitlabJson(this.api, `${project}/merge_requests?${query}`)).filter((request) => request.source_branch.startsWith(prefix)).map((request) => ({
+					branch: request.source_branch,
+					url: request.web_url,
+					title: request.title
+				}));
+			},
+			closeReview: async (branch) => {
+				for (const request of await openRequests(branch)) await gitlabRequest(this.api, `${project}/merge_requests/${request.iid}`, {
+					method: "PUT",
+					body: { state_event: "close" },
+					allow: [403, 404]
 				});
-				const [open] = await gitlabJson(this.api, `${project}/merge_requests?${query}`);
-				if (!open) throw new GitApiError(409, "GitLab couldn't open the merge request.");
-				return { url: open.web_url };
 			}
 		};
 	}
@@ -957,6 +1088,7 @@ var GitLabBackend = class GitLabBackend {
 				}
 			});
 			this.pinned = commit.id;
+			if (commit.parent_ids?.length === 1 && commit.parent_ids[0] === expectedRevision) await this.carryTree(existing, commit.id, changes).catch(() => {});
 			return { revision: commit.id };
 		} catch (error) {
 			if (!(error instanceof GitApiError)) throw error;
@@ -965,6 +1097,22 @@ var GitLabBackend = class GitLabBackend {
 			throw error;
 		}
 	}
+	/** Lists `revision`'s editable files as `before`'s with `changes` made, keeping the text written. */
+	async carryTree(before, revision, changes) {
+		if (this.trees.has(revision) || !globalThis.crypto?.subtle) return;
+		const tree = new Map(before);
+		for (const change of changes) {
+			if (!EDITABLE_FOLDERS.some((folder) => change.path.startsWith(`${folder}/`))) continue;
+			if ("delete" in change) {
+				tree.delete(change.path);
+				continue;
+			}
+			const id = await gitBlobId("bytes" in change ? change.bytes : new TextEncoder().encode(change.content));
+			tree.set(change.path, id);
+			if ("content" in change && !this.blobs.has(id)) this.blobs.set(id, Promise.resolve(change.content));
+		}
+		this.trees.set(revision, Promise.resolve(tree));
+	}
 	async history(path, { page = 1, perPage = 20 } = {}) {
 		const query = new URLSearchParams({
 			ref_name: this.pinned ?? await this.revision(),
@@ -1366,7 +1514,7 @@ function browserLocation() {
 function gitlab(options) {
 	const webUrl = (options.url ?? "https://gitlab.com").replace(/\/$/, "");
 	const apiUrl = `${webUrl}/api/v4`;
-	const fetcher = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	const fetcher = withRateLimits(options.fetch ?? ((input, init) => globalThis.fetch(input, init)), { host: "GitLab" });
 	const storage = credentialStorage(`goodfellow:gitlab:${webUrl}:${options.project}`, options.storage);
 	const pending = credentialStorage(`goodfellow:gitlab:pending:${options.project}`, options.storage);
 	const location = () => options.location ?? browserLocation();

package/dist/testing.d.ts

@@ -28,6 +28,8 @@ export interface FakeGitLabOptions {
    * Pages: a commit status with no pipeline the project lists.
    */
   external?: boolean;
+  /** A paid plan, whose merge requests take several reviewers; the free plan takes one. */
+  premium?: boolean;
   /** The job the update runs in, which `addUpdateRun()` logs: `pages` by default, as in the starters, or a code project's `update`. */
   updateJob?: string;
   /** Groups the users belong to, which new projects can be created in. */
@@ -42,6 +44,12 @@ export interface FakeGitLabOptions {
   accounts?: string[];
   /** Who can see the project. Private by default. */
   visibility?: "public" | "internal" | "private";
+  /**
+   * Answers plugins' tasks, as the site's `plugin-task` job would: given each
+   * pipeline's task variables, it gives the text the job leaves as its
+   * artifact, or nothing for a job that fails. Without it, task pipelines fail.
+   */
+  tasks?: (variables: Record<string, string>) => string | undefined | Promise<string | undefined>;
 }
 /** A pipeline schedule, such as the nightly one or one the admin panel adds for a scheduled change. */
 export interface FakeSchedule {

package/dist/testing.js

@@ -173,6 +173,8 @@ function fakeGitLab(options) {
 		updateRuns.push(added);
 		return added;
 	}
+	/** Pipelines started for plugins' tasks, with their `plugin-task` job's artifact. */
+	const taskRuns = [];
 	/** Failed jobs, by commit, which tests add with `failBuild()` and `cancelBuild()`. */
 	const failures = /* @__PURE__ */ new Map();
 	/**
@@ -564,9 +566,28 @@ function fakeGitLab(options) {
 			const source = url.searchParams.get("source_branch");
 			return json(repo.reviews.filter((review) => review.state === "open" && (!source || review.branch === source)).map((review) => ({
 				iid: review.number,
+				title: review.title,
+				source_branch: review.branch,
 				web_url: `${webUrl}/${options.project}/-/merge_requests/${review.number}`
 			})));
 		}
+		const mergeRequest = rest.match(/^\/merge_requests\/(\d+)$/);
+		if (mergeRequest && request.method === "PUT") {
+			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const review = repo.reviews.find((found) => found.number === Number(mergeRequest[1]));
+			if (!review) return json({ message: "404 Not found" }, 404);
+			const body = await request.json();
+			if (body.reviewer_ids) {
+				if (body.reviewer_ids.length > 1 && !options.premium) return json({ message: "Too many reviewers" }, 400);
+				const names = new Map([...accounts].map(([username, id]) => [id, username]));
+				review.reviewers = body.reviewer_ids.flatMap((id) => names.get(id) ?? []);
+			}
+			if (body.state_event === "close") review.state = "closed";
+			return json({
+				iid: review.number,
+				state: review.state === "open" ? "opened" : review.state
+			});
+		}
 		if (rest === "/repository/tree") {
 			const ref = url.searchParams.get("ref") ?? repo.defaultBranch;
 			const dir = url.searchParams.get("path") ?? "";
@@ -628,9 +649,11 @@ function fakeGitLab(options) {
 				name: body.author_name,
 				email: body.author_email
 			});
+			const parent = repo.commitAt(sha)?.parent;
 			return json({
 				id: sha,
-				message: body.commit_message
+				message: body.commit_message,
+				parent_ids: parent ? [parent] : []
 			}, 201);
 		}
 		if (rest === "/repository/commits" && request.method === "GET") {
@@ -691,10 +714,25 @@ function fakeGitLab(options) {
 		})));
 		if (rest === "/pipeline" && request.method === "POST") {
 			if (accessLevel < 30) return json({ message: "403 Forbidden" }, 403);
+			const body = await request.json();
+			const variables = Object.fromEntries((body.variables ?? []).map(({ key, value }) => [key, value]));
+			if (variables.GOODFELLOW_TASK_PLUGIN) {
+				const id = 9e4 + taskRuns.length;
+				taskRuns.push({
+					id,
+					job: id + 5e4,
+					variables,
+					answer: await options.tasks?.(variables)
+				});
+				return json({
+					id,
+					status: "created"
+				}, 201);
+			}
 			const run = addUpdateRun({
 				source: "api",
 				status: "created",
-				variables: (await request.json()).variables
+				variables: body.variables
 			});
 			return json({
 				id: run.id,
@@ -787,6 +825,18 @@ function fakeGitLab(options) {
 			if (body.ci_push_repository_for_job_token_allowed !== void 0) updateSettings.jobTokenPush = body.ci_push_repository_for_job_token_allowed;
 			return json({ ci_push_repository_for_job_token_allowed: updateSettings.jobTokenPush });
 		}
+		const taskJobs = rest.match(/^\/pipelines\/(\d+)\/jobs$/);
+		const taskRun = taskJobs && taskRuns.find((candidate) => candidate.id === Number(taskJobs[1]));
+		if (taskRun) return json([{
+			id: taskRun.job,
+			name: "plugin-task",
+			status: taskRun.answer === void 0 ? "failed" : "success"
+		}]);
+		const artifact = rest.match(/^\/jobs\/(\d+)\/artifacts\/(.+)$/);
+		if (artifact) {
+			const run = taskRuns.find((candidate) => candidate.job === Number(artifact[1]));
+			return run?.answer !== void 0 && artifact[2] === "goodfellow-task-result.json" ? new Response(`${run.answer}\n`) : json({ message: "404 Not Found" }, 404);
+		}
 		const updateJobs = rest.match(/^\/pipelines\/(\d{4,})\/jobs$/);
 		if (updateJobs) {
 			const run = updateRuns.find((candidate) => candidate.id === Number(updateJobs[1]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodfellow-cms/gitlab",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Edit a Goodfellow site stored on GitLab, straight from the browser.",
   "keywords": [
     "goodfellow",
@@ -35,7 +35,7 @@
     "dist"
   ],
   "dependencies": {
-    "@goodfellow-cms/core": "0.5.0"
+    "@goodfellow-cms/core": "0.7.0"
   },
   "devDependencies": {
     "@puckeditor/core": "0.23.0"