@janmarkuslanger/astro-strapi-platform 0.0.0-stage → 0.1.1

package/dist/strapi-kit/schemas-cli.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncSchemas = syncSchemas;
+exports.main = main;
+/**
+ * Writes the platform schemas into the Strapi app in the current directory.
+ * Runs before `strapi develop` and `strapi build` (the app's pre-scripts), so
+ * a version bump of this package is all it takes to update them.
+ *
+ * Called through `require(…).main()`, not an npm `bin`: in the platform repo
+ * `dist/` does not exist yet at `npm ci`, and npm then links no bin at all.
+ *
+ *   src/**                       generated, committed, never edited by hand
+ *   schema-extensions/<name>.json  the site's additions (info, new attributes)
+ *   platform-schemas.json      manifest of what was generated last
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const schemas_1 = require("./schemas");
+const MANIFEST = "platform-schemas.json";
+const PLATFORM_DIR = node_path_1.default.join(__dirname, "..", "..", "schemas");
+function readTree(root, dir = "") {
+    const files = {};
+    for (const entry of node_fs_1.default.readdirSync(node_path_1.default.join(root, dir), { withFileTypes: true })) {
+        const rel = dir ? `${dir}/${entry.name}` : entry.name;
+        if (entry.isDirectory())
+            Object.assign(files, readTree(root, rel));
+        else
+            files[rel] = node_fs_1.default.readFileSync(node_path_1.default.join(root, rel), "utf8");
+    }
+    return files;
+}
+const readIfExists = (file) => node_fs_1.default.existsSync(file) ? node_fs_1.default.readFileSync(file, "utf8") : undefined;
+function parseJson(file) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        throw new schemas_1.SchemaError([`${file}: ${error.message}`]);
+    }
+}
+/** Removes `dir` and its parents up to `stop` while they are empty. */
+function pruneEmpty(dir, stop) {
+    while (dir !== stop && node_fs_1.default.existsSync(dir) && node_fs_1.default.readdirSync(dir).length === 0) {
+        node_fs_1.default.rmdirSync(dir);
+        dir = node_path_1.default.dirname(dir);
+    }
+}
+function syncSchemas(appDir, platformDir = PLATFORM_DIR) {
+    const src = node_path_1.default.join(appDir, "src");
+    const platform = readTree(platformDir);
+    const blocksDir = node_path_1.default.join(src, "components", "blocks");
+    const siteBlocks = node_fs_1.default.existsSync(blocksDir)
+        ? node_fs_1.default
+            .readdirSync(blocksDir)
+            .filter((f) => f.endsWith(".json") && !(`components/blocks/${f}` in platform))
+            .map((f) => f.slice(0, -".json".length))
+        : [];
+    const extensionsDir = node_path_1.default.join(appDir, "schema-extensions");
+    const extensions = {};
+    if (node_fs_1.default.existsSync(extensionsDir)) {
+        for (const f of node_fs_1.default.readdirSync(extensionsDir).filter((f) => f.endsWith(".json"))) {
+            extensions[f.slice(0, -".json".length)] = parseJson(node_path_1.default.join(extensionsDir, f));
+        }
+    }
+    const generated = (0, schemas_1.buildSchemas)({ platform, siteBlocks, extensions });
+    const manifestFile = node_path_1.default.join(appDir, MANIFEST);
+    const manifest = node_fs_1.default.existsSync(manifestFile) ? parseJson(manifestFile).files : {};
+    const disk = {};
+    for (const rel of new Set([...Object.keys(generated), ...Object.keys(manifest)])) {
+        disk[rel] = readIfExists(node_path_1.default.join(src, rel));
+    }
+    const plan = (0, schemas_1.planSync)(manifest, disk, generated);
+    for (const [rel, content] of Object.entries(plan.write)) {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(node_path_1.default.join(src, rel)), { recursive: true });
+        node_fs_1.default.writeFileSync(node_path_1.default.join(src, rel), content);
+    }
+    for (const rel of plan.remove) {
+        node_fs_1.default.rmSync(node_path_1.default.join(src, rel));
+        pruneEmpty(node_path_1.default.dirname(node_path_1.default.join(src, rel)), src);
+    }
+    node_fs_1.default.writeFileSync(manifestFile, `${JSON.stringify({ $comment: "Generated by platform-schemas. Do not edit.", files: plan.manifest }, null, 2)}\n`);
+    return { written: Object.keys(plan.write).length, removed: plan.remove.length };
+}
+function main() {
+    try {
+        const { written, removed } = syncSchemas(process.cwd());
+        console.log(`platform-schemas: ${written} written, ${removed} removed.`);
+    }
+    catch (error) {
+        if (error instanceof schemas_1.SchemaError) {
+            console.error("platform-schemas: refusing to write platform schemas:");
+            for (const problem of error.problems)
+                console.error(`  - ${problem}`);
+        }
+        else {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+}

package/dist/strapi-kit/schemas.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Platform schemas for a site's Strapi app. Pure: the CLI (schemas-cli.ts)
+ * reads and writes the files, everything deciding *what* to write lives here.
+ *
+ * The platform owns its content types and components (page, shared-block,
+ * global, shared.*, blocks.reference). A site extends them through
+ * `schema-extensions/<name>.json` and never edits the generated files —
+ * otherwise the next platform version could not update them.
+ */
+/** Paths relative to the Strapi app's `src/`, posix separators. */
+export type FileMap = Record<string, string>;
+export interface SchemaInputs {
+    /** The platform's schema files, as shipped in this package. */
+    platform: FileMap;
+    /** Names of the site's own block components (`src/components/blocks/<name>.json`). */
+    siteBlocks: string[];
+    /** Parsed `schema-extensions/<name>.json`, keyed by `<name>`. */
+    extensions: Record<string, unknown>;
+}
+/** Path → sha256 of each generated file, as last written. */
+export type Manifest = Record<string, string>;
+export interface SyncPlan {
+    write: FileMap;
+    remove: string[];
+    manifest: Manifest;
+}
+/** Every problem found, so one run reports them all. */
+export declare class SchemaError extends Error {
+    readonly problems: string[];
+    constructor(problems: string[]);
+}
+/**
+ * Extension name of a platform schema file: the content type's singular name
+ * (`page`) or the component uid (`shared.seo`). The dot keeps them apart.
+ */
+export declare function extensionName(path: string): string | null;
+/**
+ * The files the site's `src/` must contain: platform schemas with the site's
+ * extensions applied and every site block added to the platform's dynamic
+ * zones. Blocks the platform lists itself (`blocks.reference` on pages) keep
+ * their place; `shared-block` lists none, so a shared block can never hold a
+ * reference and cycles stay impossible by construction.
+ */
+export declare function buildSchemas({ platform, siteBlocks, extensions }: SchemaInputs): FileMap;
+export declare const hash: (content: string) => string;
+/**
+ * What to write and remove so `src/` matches `generated`, refusing to
+ * overwrite anything a person changed. A generated file that differs from its
+ * manifest hash was edited by hand (e.g. in the Content-Type Builder); a file
+ * the manifest does not know but that differs from the platform's was never
+ * generated. Both would be lost silently, so both stop the run instead.
+ *
+ * @param disk current content of every path in `generated` or `manifest`,
+ *   `undefined` where the file does not exist
+ */
+export declare function planSync(manifest: Manifest, disk: Record<string, string | undefined>, generated: FileMap): SyncPlan;

package/dist/strapi-kit/schemas.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = exports.SchemaError = void 0;
+exports.extensionName = extensionName;
+exports.buildSchemas = buildSchemas;
+exports.planSync = planSync;
+const node_crypto_1 = require("node:crypto");
+/** Every problem found, so one run reports them all. */
+class SchemaError extends Error {
+    problems;
+    constructor(problems) {
+        super(problems.join("\n"));
+        this.problems = problems;
+        this.name = "SchemaError";
+    }
+}
+exports.SchemaError = SchemaError;
+const EXTENSION_KEYS = new Set(["info", "attributes"]);
+// Not singularName/pluralName: they name the REST routes the frontend reads.
+const EXTENSION_INFO_KEYS = new Set(["displayName", "description", "icon"]);
+const CONTENT_TYPE = /^api\/[^/]+\/content-types\/([^/]+)\/schema\.json$/;
+const COMPONENT = /^components\/([^/]+)\/([^/]+)\.json$/;
+/**
+ * Extension name of a platform schema file: the content type's singular name
+ * (`page`) or the component uid (`shared.seo`). The dot keeps them apart.
+ */
+function extensionName(path) {
+    const ct = CONTENT_TYPE.exec(path);
+    if (ct)
+        return ct[1];
+    const component = COMPONENT.exec(path);
+    if (component)
+        return `${component[1]}.${component[2]}`;
+    return null;
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function applyExtension(name, schema, extension, problems) {
+    const where = `schema-extensions/${name}.json`;
+    if (!isObject(extension)) {
+        problems.push(`${where}: must be a JSON object with "info" and/or "attributes".`);
+        return;
+    }
+    for (const key of Object.keys(extension)) {
+        if (!EXTENSION_KEYS.has(key)) {
+            problems.push(`${where}: "${key}" cannot be extended; only "info" and "attributes".`);
+        }
+    }
+    if (extension.info !== undefined) {
+        if (!isObject(extension.info)) {
+            problems.push(`${where}: "info" must be an object.`);
+        }
+        else {
+            for (const [key, value] of Object.entries(extension.info)) {
+                if (!EXTENSION_INFO_KEYS.has(key)) {
+                    problems.push(`${where}: info.${key} is owned by the platform; a site may set ${[...EXTENSION_INFO_KEYS].join(", ")}.`);
+                }
+                else if (typeof value !== "string") {
+                    problems.push(`${where}: info.${key} must be a string.`);
+                }
+                else {
+                    schema.info[key] = value;
+                }
+            }
+        }
+    }
+    if (extension.attributes !== undefined) {
+        if (!isObject(extension.attributes)) {
+            problems.push(`${where}: "attributes" must be an object.`);
+        }
+        else {
+            for (const [key, attribute] of Object.entries(extension.attributes)) {
+                if (key in schema.attributes) {
+                    problems.push(`${where}: attribute "${key}" belongs to the platform and cannot be redefined; add a field with another name.`);
+                }
+                else if (!isObject(attribute) || typeof attribute.type !== "string") {
+                    problems.push(`${where}: attribute "${key}" needs a "type".`);
+                }
+                else {
+                    schema.attributes[key] = attribute;
+                }
+            }
+        }
+    }
+}
+const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+/**
+ * The files the site's `src/` must contain: platform schemas with the site's
+ * extensions applied and every site block added to the platform's dynamic
+ * zones. Blocks the platform lists itself (`blocks.reference` on pages) keep
+ * their place; `shared-block` lists none, so a shared block can never hold a
+ * reference and cycles stay impossible by construction.
+ */
+function buildSchemas({ platform, siteBlocks, extensions }) {
+    const problems = [];
+    const files = {};
+    const known = new Set();
+    const blockUids = [...siteBlocks].sort().map((name) => `blocks.${name}`);
+    for (const [path, content] of Object.entries(platform)) {
+        const name = extensionName(path);
+        if (!name) {
+            files[path] = content;
+            continue;
+        }
+        known.add(name);
+        const schema = JSON.parse(content);
+        if (CONTENT_TYPE.test(path)) {
+            for (const attribute of Object.values(schema.attributes)) {
+                if (attribute.type === "dynamiczone") {
+                    attribute.components = [...new Set([...attribute.components, ...blockUids])];
+                }
+            }
+        }
+        if (name in extensions)
+            applyExtension(name, schema, extensions[name], problems);
+        files[path] = json(schema);
+    }
+    for (const name of Object.keys(extensions)) {
+        if (!known.has(name)) {
+            problems.push(`schema-extensions/${name}.json: no platform schema "${name}". Known: ${[...known].sort().join(", ")}.`);
+        }
+    }
+    for (const name of siteBlocks) {
+        if (`components/blocks/${name}.json` in platform) {
+            problems.push(`components/blocks/${name}.json is a platform component; give the site block another name.`);
+        }
+    }
+    if (problems.length)
+        throw new SchemaError(problems);
+    return files;
+}
+const hash = (content) => (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+exports.hash = hash;
+/**
+ * What to write and remove so `src/` matches `generated`, refusing to
+ * overwrite anything a person changed. A generated file that differs from its
+ * manifest hash was edited by hand (e.g. in the Content-Type Builder); a file
+ * the manifest does not know but that differs from the platform's was never
+ * generated. Both would be lost silently, so both stop the run instead.
+ *
+ * @param disk current content of every path in `generated` or `manifest`,
+ *   `undefined` where the file does not exist
+ */
+function planSync(manifest, disk, generated) {
+    const problems = [];
+    const edited = (path) => `src/${path} was changed by hand. Platform schemas are generated: move the change into schema-extensions/, then delete the file and run again.`;
+    const write = {};
+    for (const [path, content] of Object.entries(generated)) {
+        const current = disk[path];
+        if (current === undefined) {
+            write[path] = content;
+        }
+        else if (path in manifest) {
+            if ((0, exports.hash)(current) !== manifest[path])
+                problems.push(edited(path));
+            else if (current !== content)
+                write[path] = content;
+        }
+        else if (current !== content) {
+            problems.push(`src/${path} exists but was not generated. It is a platform schema now: move site changes into schema-extensions/, then delete the file and run again.`);
+        }
+    }
+    const remove = [];
+    for (const [path, recorded] of Object.entries(manifest)) {
+        if (path in generated)
+            continue;
+        const current = disk[path];
+        if (current === undefined)
+            continue;
+        if ((0, exports.hash)(current) !== recorded)
+            problems.push(edited(path));
+        else
+            remove.push(path);
+    }
+    if (problems.length)
+        throw new SchemaError(problems);
+    const next = {};
+    for (const path of Object.keys(generated).sort())
+        next[path] = (0, exports.hash)(generated[path]);
+    return { write, remove, manifest: next };
+}

package/dist/strapi-kit/seed.d.ts

@@ -0,0 +1,52 @@
+import type { Core } from "@strapi/strapi";
+/**
+ * Initial content from fixtures.
+ *
+ * Runs exactly once, into an empty database: the fixtures are the starting
+ * state of a fresh installation, nothing more. As soon as any content exists —
+ * from an earlier seed or written in the panel — seeding steps aside and never
+ * touches the database again. The CMS is then the single source of truth, and
+ * nobody can lose an afternoon of editing to a restart.
+ *
+ * There is deliberately NO force flag. If you want one, you want a database
+ * reset instead (local SQLite: delete apps/cms/.tmp).
+ *
+ * Structure (content types, blocks, fields) still comes from code and ships
+ * with every deploy; only the *content* is one-way and one-time.
+ *
+ * Untouched either way: the media library (files are matched by name and
+ * reused, so re-seeding never piles up duplicates) and anything a visitor
+ * created, such as form submissions.
+ *
+ * All steps run in ONE transaction. A failure rolls everything back, so the
+ * next boot sees an empty database and seeds again — a half-seeded database
+ * would count as "has content" and never be completed.
+ *
+ * Extending: add a step for your content type, in dependency order. Every
+ * step's type counts as "the site already has content".
+ */
+export interface SeedStep {
+    /** Content type, e.g. "api::page.page". */
+    uid: string;
+    /** Fixture entries — an array, or a single object for a single type. */
+    entries: any[] | any;
+    /**
+     * Makes created entries referable by later steps: `{ [token]: entry[key] }`
+     * anywhere in a later fixture becomes the created documentId. Example:
+     * `{ key: "name", token: "__sharedBlock" }`.
+     */
+    ref?: {
+        key: string;
+        token: string;
+    };
+}
+export interface SeedOptions {
+    /** In dependency order: referenced types before the types that use them. */
+    steps: SeedStep[];
+    /**
+     * Images to upload, referenced in fixtures as `{ "__file": "name.jpg" }`.
+     * Default: `data/uploads` relative to the CMS app.
+     */
+    uploadsDir?: string;
+}
+export declare function seedContent(strapi: Core.Strapi, options: SeedOptions): Promise<void>;

package/dist/strapi-kit/seed.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedContent = seedContent;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+async function hasContent(strapi, uids) {
+    for (const uid of uids) {
+        const count = await strapi.documents(uid).count({});
+        if (count > 0)
+            return true;
+    }
+    return false;
+}
+/** Uploads images from apps/cms/data/uploads, indexed by file name. */
+async function uploadSeedImages(strapi, uploadDir) {
+    const uploaded = new Map();
+    if (!node_fs_1.default.existsSync(uploadDir))
+        return uploaded;
+    const uploadService = strapi.plugin("upload").service("upload");
+    for (const fileName of node_fs_1.default.readdirSync(uploadDir)) {
+        if (!/\.(jpe?g|png|webp|svg)$/i.test(fileName))
+            continue;
+        // Reuse a file already in the library — re-seeding against an emptied
+        // content table must not create duplicates.
+        const existing = await strapi.db
+            .query("plugin::upload.file")
+            .findOne({ where: { name: fileName } });
+        if (existing) {
+            uploaded.set(fileName, existing);
+            continue;
+        }
+        const filePath = node_path_1.default.join(uploadDir, fileName);
+        const ext = node_path_1.default.extname(fileName).toLowerCase();
+        const mimetype = ext === ".png" ? "image/png"
+            : ext === ".webp" ? "image/webp"
+                : ext === ".svg" ? "image/svg+xml"
+                    : "image/jpeg";
+        const [file] = await uploadService.upload({
+            data: {},
+            files: {
+                filepath: filePath,
+                originalFilename: fileName,
+                mimetype,
+                size: node_fs_1.default.statSync(filePath).size,
+            },
+        });
+        uploaded.set(fileName, file);
+    }
+    return uploaded;
+}
+/**
+ * Replaces `{ "__file": "name.jpg" }` in the fixtures with the uploaded file's
+ * id, so fixtures can reference images without knowing database ids.
+ */
+function resolveFiles(value, files) {
+    if (Array.isArray(value))
+        return value.map((v) => resolveFiles(v, files));
+    if (value && typeof value === "object") {
+        if (typeof value.__file === "string") {
+            return files.get(value.__file)?.id ?? null;
+        }
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveFiles(v, files)]));
+    }
+    return value;
+}
+async function seedContent(strapi, options) {
+    if (await hasContent(strapi, options.steps.map((step) => step.uid))) {
+        strapi.log.info("Seed: content already exists — skipped.");
+        return;
+    }
+    strapi.log.info("Seed: empty database — creating initial content.");
+    const files = await uploadSeedImages(strapi, options.uploadsDir ?? node_path_1.default.resolve(process.cwd(), "data", "uploads"));
+    /** token → (fixture key → created documentId) */
+    const refs = new Map();
+    /** Turns `{ "<token>": "Name" }` into the created entry's documentId. */
+    const resolveRefs = (value) => {
+        if (Array.isArray(value))
+            return value.map(resolveRefs);
+        if (value && typeof value === "object") {
+            for (const [token, ids] of refs) {
+                if (typeof value[token] === "string")
+                    return ids.get(value[token]) ?? null;
+            }
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveRefs(v)]));
+        }
+        return value;
+    };
+    // Document service calls join this transaction. Uploads stay outside: they
+    // touch the filesystem, and a retry reuses them by name.
+    await strapi.db.transaction(async () => {
+        for (const step of options.steps) {
+            // Types with draft & publish are created published; for the others a
+            // status means nothing.
+            const draftAndPublish = Boolean(strapi.contentType(step.uid)?.options?.draftAndPublish);
+            const entries = Array.isArray(step.entries) ? step.entries : [step.entries];
+            const ids = new Map();
+            for (const entry of entries) {
+                const created = await strapi.documents(step.uid).create({
+                    data: resolveRefs(resolveFiles(entry, files)),
+                    ...(draftAndPublish ? { status: "published" } : {}),
+                });
+                if (step.ref)
+                    ids.set(String(entry[step.ref.key]), created.documentId);
+            }
+            if (step.ref)
+                refs.set(step.ref.token, ids);
+        }
+    });
+    strapi.log.info("Seed: done.");
+}

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@janmarkuslanger/astro-strapi-platform",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Astro + Strapi platform: domain model and block contract, Strapi adapter, Astro rendering and consent, Strapi schemas and bootstrap helpers.",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "astro-component",
+    "strapi"
+  ],
+  "exports": {
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
+    },
+    "./strapi": {
+      "types": "./dist/strapi/index.d.ts",
+      "import": "./dist/strapi/index.js"
+    },
+    "./astro": "./src/astro/index.ts",
+    "./astro/BlockRenderer.astro": "./src/astro/BlockRenderer.astro",
+    "./strapi-kit": {
+      "types": "./dist/strapi-kit/index.d.ts",
+      "default": "./dist/strapi-kit/index.js"
+    },
+    "./strapi-kit/schemas-cli": "./dist/strapi-kit/schemas-cli.js"
+  },
+  "typesVersions": {
+    "*": {
+      "strapi-kit": [
+        "dist/strapi-kit/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "src/astro",
+    "schemas"
+  ],
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.strapi-kit.json && node -e \"require('node:fs').copyFileSync('src/strapi-kit/package.json', 'dist/strapi-kit/package.json')\""
+  },
+  "dependencies": {
+    "marked": "^14.1.3"
+  },
+  "peerDependencies": {
+    "astro": "^4.16.0",
+    "@strapi/strapi": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "astro": {
+      "optional": true
+    },
+    "@strapi/strapi": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/janmarkuslanger/astro-strapi-template.git",
+    "directory": "packages/astro-strapi-platform"
+  }
+}

package/schemas/api/global/content-types/global/schema.json

@@ -0,0 +1,40 @@
+{
+  "kind": "singleType",
+  "collectionName": "globals",
+  "info": {
+    "singularName": "global",
+    "pluralName": "globals",
+    "displayName": "Global settings"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "siteName": {
+      "type": "string",
+      "required": true
+    },
+    "claim": {
+      "type": "string"
+    },
+    "email": {
+      "type": "email",
+      "required": true
+    },
+    "navigation": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.link"
+    },
+    "footerLinks": {
+      "type": "component",
+      "repeatable": true,
+      "component": "shared.link"
+    }
+  }
+}

package/schemas/api/global/controllers/global.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreController("api::global.global");

package/schemas/api/global/routes/global.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreRouter("api::global.global");

package/schemas/api/global/services/global.ts

@@ -0,0 +1,3 @@
+import { factories } from "@strapi/strapi";
+
+export default factories.createCoreService("api::global.global");

package/schemas/api/page/content-types/page/schema.json

@@ -0,0 +1,39 @@
+{
+  "kind": "collectionType",
+  "collectionName": "pages",
+  "info": {
+    "singularName": "page",
+    "pluralName": "pages",
+    "displayName": "Page"
+  },
+  "options": {
+    "draftAndPublish": true
+  },
+  "pluginOptions": {
+    "content-type-builder": {
+      "visible": false
+    }
+  },
+  "attributes": {
+    "title": {
+      "type": "string",
+      "required": true
+    },
+    "slug": {
+      "type": "uid",
+      "targetField": "title",
+      "required": true
+    },
+    "seo": {
+      "type": "component",
+      "repeatable": false,
+      "component": "shared.seo"
+    },
+    "blocks": {
+      "type": "dynamiczone",
+      "components": [
+        "blocks.reference"
+      ]
+    }
+  }
+}