@void/deploy-core 0.21.9 → 0.23.0

package/README.md

@@ -9,6 +9,10 @@ manifest validation, and provider-neutral resource planning. It has no
 dependency on either deployment target and must remain usable from Node.js and
 Cloudflare Workers.
 
+SQL migration tokenization, classification, and canonical hash inputs are shared
+here. Each target supplies its hashing implementation and independently validates
+submitted plans; CLI execution policy stays in the CLI.
+
 The package also defines the adapter boundary implemented by deployment
 targets. Target-specific orchestration belongs in `void` or `platform/`, not
 here.

package/dist/index.d.mts

@@ -166,6 +166,88 @@ export declare function createDeployUploadPayload(artifact: DeployArtifact, meta
   preflight: "true" | null;
 }): DeployUploadPayload;
 //#endregion
+//#region src/canonical-json.d.ts
+export declare function canonicalJson(value: unknown): string;
+//#endregion
+//#region src/sql-tokenize.d.ts
+/**
+ * Char-by-char SQL tokenizer shared by the destructive-SQL guard
+ * (projects.ts) and the single-statement classifier (remote-runner.ts).
+ *
+ * Walks the input and yields contiguous segments. `sql` runs are
+ * emitted as `{ kind: 'sql', start, end }` so callers can `sql.slice`
+ * without character-by-character allocations. Special regions are
+ * yielded whole with their delimiters included in `[start, end)`.
+ *
+ * Lexical forms handled (SQLite / drizzle-kit SQLite output):
+ *   - `-- line`            line comments (terminate at `\n` or EOF)
+ *   - `/* block *\/`        block comments (tolerate unterminated — span to EOF)
+ *   - `'...'`              string literals with `''` doubled-quote escape
+ *   - `"..."` / `` `...` `` identifier quotes with `""` / `` `` `` escape
+ *   - `[...]`              bracket identifiers, NO `]]` escape — a single
+ *                          `]` closes the identifier (SQLite semantics;
+ *                          differs from MS SQL)
+ *
+ * Not handled — intentional, both current callers target SQLite only:
+ *   - Postgres `$tag$ ... $tag$` dollar-quoting
+ *   - Postgres `E'...'` extended string literals
+ *
+ * Adding a new quoting form anywhere should land here so both callers
+ * stay in lockstep.
+ */
+type SqlSegment = {
+  kind: "sql";
+  start: number;
+  end: number;
+} | {
+  kind: "line-comment";
+  start: number;
+  end: number;
+} | {
+  kind: "block-comment";
+  start: number;
+  end: number;
+} | {
+  kind: "string";
+  start: number;
+  end: number;
+} | {
+  kind: "ident-quote";
+  open: "\"" | "`" | "[";
+  start: number;
+  end: number;
+};
+export declare function tokenizeSql(sql: string): Generator<SqlSegment>;
+//#endregion
+//#region src/migration-plan.d.ts
+export declare const MIGRATION_CLASSIFIER_VERSION = 1;
+export declare const UNSPLIT_MULTI_STATEMENT_PRAGMA = "-- void:allow-unsplit-multi-statement";
+type SqlMigrationClassification = {
+  kind: "single-statement";
+  stability: "stable";
+} | {
+  kind: "breakpoint-framed";
+  stability: "stable";
+  statements: Array<string>;
+} | {
+  kind: "legacy-unsplit-multi-statement";
+  stability: "legacy";
+  allowLegacy: boolean;
+};
+type MigrationPlanHashInput = SqlMigrationClassification & {
+  name: string;
+  dialect: "sqlite";
+  classifierVersion: number;
+  sqlHash: string;
+};
+export declare function canonicalSql(sql: string): string;
+export declare function hasStandalonePragma(sql: string, pragma: string): boolean;
+export declare function isSingleStatement(sql: string): boolean;
+/** Classify SQL without imposing the caller's execution policy or hashing implementation. */
+export declare function classifySqlMigration(sql: string): SqlMigrationClassification;
+/** Preserve the classifier-v1 hash preimage; policy markers and warnings are not hashed. */
+export declare function getMigrationPlanHashInput(plan: MigrationPlanHashInput): unknown;
+//#endregion
 //#region src/index.d.ts
 export declare const SUPPORTED_MANIFEST_VERSIONS: ReadonlyArray<number>;
 export type MigrationMeta = {
@@ -263,6 +345,8 @@ export type SandboxMigrationMeta = {
   newSqliteClasses?: ReadonlyArray<string>;
   deletedClasses?: ReadonlyArray<string>;
 };
+/** Named images under the Durable Object scheduling policy must be digest-pinned. */
+export declare function isSandboxRegistryImage(image: string): boolean;
 export type SandboxManifestMeta = {
   bindingName: string;
   className: string;
@@ -273,10 +357,10 @@ export type SandboxManifestMeta = {
   migrations?: ReadonlyArray<SandboxMigrationMeta>;
   /** Written by the managed platform, never accepted from deployment clients. */
   runtime?: {
-    protocol: 1;
+    protocol: 1 | 2;
   };
   /** Managed transport implemented by the application's bundled Void runtime. */
-  controllerProtocol?: 1;
+  controllerProtocol?: 1 | 2;
 };
 export type LiveMigrationMeta = {
   tag: string;
@@ -405,4 +489,4 @@ export type DeployEvent = {
   step: string;
 };
 //#endregion
-export type { DeployAppType, DeployArtifact, DeployAssetManifestEntry, DeployAssetUploadRequest, DeployCapabilitySupport, DeployIntent, DeployResource, DeployResourcePlan, DeployRuntimeFeatures, DeploySourceMetadata, DeployTarget, DeployTargetAdapter, DeployTargetCapabilities, DeployUploadPayload };
+export type { DeployAppType, DeployArtifact, DeployAssetManifestEntry, DeployAssetUploadRequest, DeployCapabilitySupport, DeployIntent, DeployResource, DeployResourcePlan, DeployRuntimeFeatures, DeploySourceMetadata, DeployTarget, DeployTargetAdapter, DeployTargetCapabilities, DeployUploadPayload, MigrationPlanHashInput, SqlMigrationClassification, SqlSegment };

package/dist/index.mjs

@@ -395,6 +395,213 @@ function createDeployUploadPayload(artifact, metadata) {
 	};
 }
 //#endregion
+//#region src/canonical-json.ts
+function canonicalJson(value) {
+	if (value === null) return "null";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+	if (typeof value === "object") {
+		const object = value;
+		return `{${Object.keys(object).sort().filter((key) => object[key] !== void 0).map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
+	}
+	throw new TypeError(`Unsupported canonical JSON value: ${typeof value}`);
+}
+//#endregion
+//#region src/sql-tokenize.ts
+function* tokenizeSql(sql) {
+	const sqlLength = sql.length;
+	let index = 0;
+	let runStart = 0;
+	const flushRun = (upTo) => {
+		if (upTo > runStart) return {
+			kind: "sql",
+			start: runStart,
+			end: upTo
+		};
+	};
+	while (index < sqlLength) {
+		const character = sql[index];
+		const next = index + 1 < sqlLength ? sql[index + 1] : "";
+		if (character === "-" && next === "-") {
+			const run = flushRun(index);
+			if (run) yield run;
+			let scanIndex = index + 2;
+			while (scanIndex < sqlLength && sql[scanIndex] !== "\n") scanIndex++;
+			yield {
+				kind: "line-comment",
+				start: index,
+				end: scanIndex
+			};
+			index = scanIndex;
+			runStart = index;
+			continue;
+		}
+		if (character === "/" && next === "*") {
+			const run = flushRun(index);
+			if (run) yield run;
+			let scanIndex = index + 2;
+			while (scanIndex < sqlLength - 1 && !(sql[scanIndex] === "*" && sql[scanIndex + 1] === "/")) scanIndex++;
+			const end = Math.min(scanIndex + 2, sqlLength);
+			yield {
+				kind: "block-comment",
+				start: index,
+				end
+			};
+			index = end;
+			runStart = index;
+			continue;
+		}
+		if (character === "'") {
+			const run = flushRun(index);
+			if (run) yield run;
+			let scanIndex = index + 1;
+			while (scanIndex < sqlLength) {
+				if (sql[scanIndex] === "'" && sql[scanIndex + 1] === "'") {
+					scanIndex += 2;
+					continue;
+				}
+				if (sql[scanIndex] === "'") {
+					scanIndex++;
+					break;
+				}
+				scanIndex++;
+			}
+			yield {
+				kind: "string",
+				start: index,
+				end: scanIndex
+			};
+			index = scanIndex;
+			runStart = index;
+			continue;
+		}
+		if (character === "\"" || character === "`" || character === "[") {
+			const run = flushRun(index);
+			if (run) yield run;
+			const close = character === "[" ? "]" : character;
+			let scanIndex = index + 1;
+			while (scanIndex < sqlLength) {
+				if (close !== "]" && sql[scanIndex] === close && sql[scanIndex + 1] === close) {
+					scanIndex += 2;
+					continue;
+				}
+				if (sql[scanIndex] === close) {
+					scanIndex++;
+					break;
+				}
+				scanIndex++;
+			}
+			yield {
+				kind: "ident-quote",
+				open: character,
+				start: index,
+				end: scanIndex
+			};
+			index = scanIndex;
+			runStart = index;
+			continue;
+		}
+		index++;
+	}
+	const tail = flushRun(sqlLength);
+	if (tail) yield tail;
+}
+//#endregion
+//#region src/migration-plan.ts
+const MIGRATION_CLASSIFIER_VERSION = 1;
+const UNSPLIT_MULTI_STATEMENT_PRAGMA = "-- void:allow-unsplit-multi-statement";
+function canonicalSql(sql) {
+	return (sql.charCodeAt(0) === 65279 ? sql.slice(1) : sql).replace(/\r\n?/g, "\n");
+}
+function isStandalonePragmaLine(line, pragma) {
+	return line.trim() === pragma;
+}
+function hasStandalonePragma(sql, pragma) {
+	return canonicalSql(sql).split("\n").some((line) => isStandalonePragmaLine(line, pragma));
+}
+function isBreakpointComment(text) {
+	return text.trim() === "--> statement-breakpoint";
+}
+function splitBreakpointFramedSql(sql) {
+	const normalized = canonicalSql(sql);
+	const statements = [];
+	let cursor = 0;
+	for (const segment of tokenizeSql(normalized)) {
+		if (segment.kind !== "line-comment") continue;
+		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) {
+			const statement = normalized.slice(cursor, segment.start).trim();
+			if (statement) statements.push(statement);
+			cursor = segment.end;
+		}
+	}
+	const statement = normalized.slice(cursor).trim();
+	if (statement) statements.push(statement);
+	return statements;
+}
+function hasStatementBreakpointOutsideLiterals(sql) {
+	const normalized = canonicalSql(sql);
+	for (const segment of tokenizeSql(normalized)) {
+		if (segment.kind !== "line-comment") continue;
+		if (isBreakpointComment(normalized.slice(segment.start, segment.end))) return true;
+	}
+	return false;
+}
+function isSingleStatement(sql) {
+	const normalized = canonicalSql(sql);
+	let statements = 0;
+	let inStatement = false;
+	for (const segment of tokenizeSql(normalized)) {
+		if (segment.kind === "line-comment" || segment.kind === "block-comment") continue;
+		if (segment.kind === "string" || segment.kind === "ident-quote") {
+			inStatement = true;
+			continue;
+		}
+		for (let index = segment.start; index < segment.end; index++) {
+			const character = normalized[index];
+			if (character === ";") {
+				if (inStatement) {
+					statements++;
+					inStatement = false;
+				}
+				continue;
+			}
+			if (character !== " " && character !== "	" && character !== "\n" && character !== "\r") inStatement = true;
+		}
+	}
+	if (inStatement) statements++;
+	return statements === 1;
+}
+/** Classify SQL without imposing the caller's execution policy or hashing implementation. */
+function classifySqlMigration(sql) {
+	if (hasStatementBreakpointOutsideLiterals(sql)) return {
+		kind: "breakpoint-framed",
+		stability: "stable",
+		statements: splitBreakpointFramedSql(sql)
+	};
+	if (isSingleStatement(sql)) return {
+		kind: "single-statement",
+		stability: "stable"
+	};
+	return {
+		kind: "legacy-unsplit-multi-statement",
+		stability: "legacy",
+		allowLegacy: hasStandalonePragma(sql, UNSPLIT_MULTI_STATEMENT_PRAGMA)
+	};
+}
+/** Preserve the classifier-v1 hash preimage; policy markers and warnings are not hashed. */
+function getMigrationPlanHashInput(plan) {
+	const base = {
+		classifierVersion: plan.classifierVersion,
+		dialect: plan.dialect,
+		kind: plan.kind,
+		name: plan.name,
+		sqlHash: plan.sqlHash,
+		stability: plan.stability
+	};
+	if (plan.kind === "breakpoint-framed") base.statements = plan.statements;
+	return base;
+}
+//#endregion
 //#region src/index.ts
 const SUPPORTED_MANIFEST_VERSIONS = [3];
 /**
@@ -470,5 +677,9 @@ function sortUniqueStrings(values) {
 function sameStringSet(a, b) {
 	return a.length === b.length && a.every((value, index) => value === b[index]);
 }
+/** Named images under the Durable Object scheduling policy must be digest-pinned. */
+function isSandboxRegistryImage(image) {
+	return /^registry\.cloudflare\.com\/[^/@\s]+\/[^@\s]+@sha256:[a-f\d]{64}$/.test(image);
+}
 //#endregion
-export { DEPLOY_ARTIFACT_VERSION, MANIFEST_REDIRECT_RULE_STATUSES, MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES, MAX_ROUTING_RULES, SUPPORTED_MANIFEST_VERSIONS, appendSqliteClassMigration, createDeployArtifact, createDeployIntent, createDeployResourcePlan, createDeployUploadPayload, planWebSocketMigrations, validateManifestShape };
+export { DEPLOY_ARTIFACT_VERSION, MANIFEST_REDIRECT_RULE_STATUSES, MAX_REVALIDATE_QUERY_ALLOWLIST_ENTRIES, MAX_ROUTING_RULES, MIGRATION_CLASSIFIER_VERSION, SUPPORTED_MANIFEST_VERSIONS, UNSPLIT_MULTI_STATEMENT_PRAGMA, appendSqliteClassMigration, canonicalJson, canonicalSql, classifySqlMigration, createDeployArtifact, createDeployIntent, createDeployResourcePlan, createDeployUploadPayload, getMigrationPlanHashInput, hasStandalonePragma, isSandboxRegistryImage, isSingleStatement, planWebSocketMigrations, tokenizeSql, validateManifestShape };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@void/deploy-core",
-  "version": "0.21.9",
+  "version": "0.23.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -21,7 +21,7 @@
   },
   "devDependencies": {
     "typescript": "7.0.2",
-    "vite-plus": "0.3.1"
+    "vite-plus": "1.0.0"
   },
   "scripts": {
     "build": "vp pack",