@treeseed/sdk 0.4.9 → 0.4.10

package/dist/platform/utils/site-config-schema.js

@@ -166,6 +166,108 @@ function parseTheme(value, path) {
 	};
 }
 
+function parseAccessRoles(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([roleId, rawRole]) => {
+			const parsedRole = expectRecord(rawRole, `${path}.${roleId}`);
+			return [
+				roleId,
+				{
+					grants: stringArray(parsedRole.grants, `${path}.${roleId}.grants`),
+				},
+			];
+		}),
+	);
+}
+
+function parseAccessPolicies(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([policyId, rawPolicy]) => {
+			const parsedPolicy = expectRecord(rawPolicy, `${path}.${policyId}`);
+			return [
+				policyId,
+				{
+					audience: optionalString(parsedPolicy.audience, `${path}.${policyId}.audience`),
+					entitlement: optionalString(parsedPolicy.entitlement, `${path}.${policyId}.entitlement`),
+					offer: optionalString(parsedPolicy.offer, `${path}.${policyId}.offer`),
+					visibility: optionalString(parsedPolicy.visibility, `${path}.${policyId}.visibility`),
+				},
+			];
+		}),
+	);
+}
+
+function parseAccessDefaults(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return { models: {} };
+	}
+
+	const models = optionalRecord(record.models, `${path}.models`) ?? {};
+	return {
+		models: Object.fromEntries(
+			Object.entries(models).map(([modelId, rawSurfaces]) => {
+				const parsedSurfaces = expectRecord(rawSurfaces, `${path}.models.${modelId}`);
+				return [
+					modelId,
+					Object.fromEntries(
+						Object.entries(parsedSurfaces).map(([surfaceId, rawPolicy]) => [
+							surfaceId,
+							expectString(rawPolicy, `${path}.models.${modelId}.${surfaceId}`),
+						]),
+					),
+				];
+			}),
+		),
+	};
+}
+
+function parseAccessBootstrap(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	const owners = optionalRecord(record.owners, `${path}.owners`);
+	return {
+		owners: owners
+			? {
+				emails: stringArray(owners.emails, `${path}.owners.emails`),
+				roles: stringArray(owners.roles, `${path}.owners.roles`),
+			}
+			: undefined,
+	};
+}
+
+function parseAccess(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {
+			roles: {},
+			policies: {},
+			defaults: { models: {} },
+			bootstrap: {},
+		};
+	}
+
+	return {
+		roles: parseAccessRoles(record.roles, `${path}.roles`),
+		policies: parseAccessPolicies(record.policies, `${path}.policies`),
+		defaults: parseAccessDefaults(record.defaults, `${path}.defaults`),
+		bootstrap: parseAccessBootstrap(record.bootstrap, `${path}.bootstrap`),
+	};
+}
+
 /** @type {TreeseedFieldAliasRegistry} */
 const siteFieldAliases = {
 	siteUrl: { key: 'siteUrl', aliases: ['site_url'] },
@@ -228,6 +330,7 @@ export function parseSiteConfig(source) {
 		emailNotificationFieldAliases,
 		expectRecord(site.emailNotifications, 'site.emailNotifications'),
 	);
+	const access = parseAccess(parsed.access, 'access');
 
 	return {
 		site: {
@@ -317,5 +420,6 @@ export function parseSiteConfig(source) {
 				},
 			},
 		},
+		access,
 	};
 }

package/dist/plugin-default.d.ts

@@ -14,6 +14,8 @@ declare const _default: {
         };
         deploy: string[];
         content: {
+            runtime: string[];
+            publish: string[];
             docs: string[];
         };
         site: string[];

package/dist/plugin-default.js

@@ -24,6 +24,8 @@ var plugin_default_default = defineTreeseedPlugin({
     },
     deploy: ["cloudflare"],
     content: {
+      runtime: ["filesystem", "team_scoped_r2_overlay"],
+      publish: ["filesystem", "team_scoped_r2_overlay"],
       docs: ["default"]
     },
     site: ["default"]

package/dist/scripts/check-build-warnings.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const args = process.argv.slice(2);
+const allowlisted = [];
+const files = [];
+
+for (let index = 0; index < args.length; index += 1) {
+	const arg = args[index];
+	if (arg === '--allow') {
+		const pattern = args[index + 1];
+		if (!pattern) {
+			throw new Error('Missing value for --allow.');
+		}
+		allowlisted.push(new RegExp(pattern));
+		index += 1;
+		continue;
+	}
+	files.push(arg);
+}
+
+if (files.length === 0) {
+	throw new Error('Usage: node check-build-warnings.mjs <log-file> [<log-file> ...] [--allow <regex>]');
+}
+
+const warningLines = [];
+for (const file of files) {
+	const contents = readFileSync(resolve(process.cwd(), file), 'utf8');
+	for (const line of contents.split(/\r?\n/u)) {
+		if (!line.includes('[WARN]')) {
+			continue;
+		}
+		if (allowlisted.some((pattern) => pattern.test(line))) {
+			continue;
+		}
+		warningLines.push(line);
+	}
+}
+
+if (warningLines.length > 0) {
+	console.error('Unexpected build warnings detected:');
+	for (const line of warningLines) {
+		console.error(`- ${line}`);
+	}
+	process.exit(1);
+}
+
+console.log('No unexpected build warnings detected.');

package/dist/scripts/config-treeseed.js

@@ -74,6 +74,13 @@ try {
         console.log(`Machine key: ${keyPath}`);
         console.log(`Updated values: ${applyResult.updated.length}`);
         console.log(`Initialized environments: ${result.initialized.length}`);
+        for (const scope of scopes) {
+            const readiness = result.readinessByScope?.[scope];
+            if (!readiness)
+                continue;
+            const status = readiness.deployable ? 'deployable' : readiness.provisioned ? 'provisioned' : readiness.configured ? 'configured' : 'pending';
+            console.log(`Readiness (${scope}): ${status}`);
+        }
         if (result.synced.github) {
             console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
         }

package/dist/scripts/tenant-workflow-action.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { resolveScope, runProjectPlatformAction, } from '../operations/services/project-platform.js';
+const tenantRoot = process.cwd();
+function parseArgs(argv) {
+    const parsed = {
+        action: 'deploy_code',
+        environment: null,
+        projectId: null,
+        previewId: null,
+        dryRun: false,
+    };
+    const rest = [...argv];
+    while (rest.length) {
+        const current = rest.shift();
+        if (!current)
+            continue;
+        if (current === '--action') {
+            parsed.action = (rest.shift() ?? parsed.action);
+            continue;
+        }
+        if (current.startsWith('--action=')) {
+            parsed.action = (current.split('=', 2)[1] ?? parsed.action);
+            continue;
+        }
+        if (current === '--environment') {
+            parsed.environment = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--environment=')) {
+            parsed.environment = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--project-id') {
+            parsed.projectId = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--project-id=')) {
+            parsed.projectId = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--preview-id') {
+            parsed.previewId = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--preview-id=')) {
+            parsed.previewId = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--dry-run') {
+            parsed.dryRun = true;
+            continue;
+        }
+        throw new Error(`Unknown workflow action argument: ${current}`);
+    }
+    return parsed;
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    const scope = resolveScope(options.environment);
+    const result = await runProjectPlatformAction(options.action, {
+        tenantRoot,
+        scope,
+        projectId: options.projectId ?? process.env.TREESEED_PROJECT_ID ?? null,
+        previewId: options.previewId,
+        dryRun: options.dryRun,
+    });
+    if (result !== undefined) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+}
+await main();