@contember/schema-migrations 2.2.0-alpha.6 → 2.2.0-alpha.8

package/dist/types/utils/applyPatchCopyOnWrite.d.ts

@@ -0,0 +1,10 @@
+import { Operation } from 'rfc6902';
+/**
+ * Applies the patch to a copy of `root`, leaving `root` untouched. Only the containers on the paths
+ * the patch writes to are copied; everything else stays shared with `root`.
+ */
+export declare const applyPatchCopyOnWrite: <T extends object>(root: T, patch: Operation[]) => {
+    result: T;
+    errors: Error[];
+};
+//# sourceMappingURL=applyPatchCopyOnWrite.d.ts.map

package/dist/types/utils/applyPatchCopyOnWrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyPatchCopyOnWrite.d.ts","sourceRoot":"","sources":["../../../src/utils/applyPatchCopyOnWrite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,SAAS,EAAW,MAAM,SAAS,CAAA;AAsBxD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,MAAM,QAAQ,CAAC,SAAS,SAAS,EAAE,KAAG;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAiBjH,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contember/schema-migrations",
-  "version": "2.2.0-alpha.6",
+  "version": "2.2.0-alpha.8",
   "license": "Apache-2.0",
   "main": "./dist/production/index.js",
   "typings": "./dist/types/index.d.ts",
@@ -23,16 +23,16 @@
     }
   },
   "dependencies": {
-    "@contember/database": "2.2.0-alpha.6",
-    "@contember/database-migrations": "2.2.0-alpha.6",
-    "@contember/engine-common": "2.2.0-alpha.6",
-    "@contember/schema": "2.2.0-alpha.6",
-    "@contember/schema-utils": "2.2.0-alpha.6",
+    "@contember/database": "2.2.0-alpha.8",
+    "@contember/database-migrations": "2.2.0-alpha.8",
+    "@contember/engine-common": "2.2.0-alpha.8",
+    "@contember/schema": "2.2.0-alpha.8",
+    "@contember/schema-utils": "2.2.0-alpha.8",
     "fast-deep-equal": "^3.1.3",
     "rfc6902": "^5.2.0"
   },
   "devDependencies": {
-    "@contember/schema-definition": "2.2.0-alpha.6"
+    "@contember/schema-definition": "2.2.0-alpha.8"
   },
   "peerDependencies": {
     "pg": "^8.20.0"

package/src/modifications/acl/PatchAclSchemaModification.ts

@@ -1,7 +1,7 @@
 import { SchemaUpdater } from '../utils/schemaUpdateUtils.js'
 import { createModificationType, ModificationHandler } from '../ModificationHandler.js'
-import { applyPatch, Operation } from 'rfc6902'
-import deepCopy from '../../utils/deepCopy.js'
+import { Operation } from 'rfc6902'
+import { applyPatchCopyOnWrite } from '../../utils/applyPatchCopyOnWrite.js'
 
 export class PatchAclSchemaModificationHandler implements ModificationHandler<PatchAclSchemaModificationData> {
 	constructor(private readonly data: PatchAclSchemaModificationData) {}
@@ -10,10 +10,9 @@ export class PatchAclSchemaModificationHandler implements ModificationHandler<Pa
 
 	public getSchemaUpdater(): SchemaUpdater {
 		return ({ schema }) => {
-			const acl = deepCopy(schema.acl)
-			const result = applyPatch(acl, this.data.patch).filter(it => it !== null)
-			if (result.length > 0) {
-				throw result[0]
+			const { result: acl, errors } = applyPatchCopyOnWrite(schema.acl, this.data.patch)
+			if (errors.length > 0) {
+				throw errors[0]
 			}
 
 			return {

package/src/modifications/columns/CreateColumnModification.ts

@@ -6,6 +6,7 @@ import { isColumn } from '@contember/schema-utils'
 import { createFields } from '../utils/diffUtils.js'
 import { getColumnSqlType } from '../utils/columnUtils.js'
 import { fillSeed, formatSeedExpression } from './columnUtils.js'
+import { wrapIdentifier } from '../../utils/dbHelpers.js'
 
 export class CreateColumnModificationHandler implements ModificationHandler<CreateColumnModificationData> {
 	constructor(private readonly data: CreateColumnModificationData, private readonly schema: Schema) {}
@@ -32,7 +33,7 @@ export class CreateColumnModificationHandler implements ModificationHandler<Crea
 				type: columnType,
 				notNull: !column.nullable && seedExpression === null,
 				sequenceGenerated: column.sequence,
-				collation: column.collation,
+				collation: column.collation !== undefined ? wrapIdentifier(column.collation) : undefined,
 			},
 		})
 

package/src/utils/applyPatchCopyOnWrite.ts

@@ -0,0 +1,63 @@
+import { applyPatch, Operation, Pointer } from 'rfc6902'
+
+type JsonContainer = { [key: string]: unknown } | unknown[]
+
+// Pointer.evaluate in rfc6902 skips these tokens, so the copy walk must skip them too.
+const skippedTokens = new Set(['__proto__', 'constructor', 'prototype'])
+
+const isContainer = (value: unknown): value is JsonContainer => typeof value === 'object' && value !== null
+
+const shallowCopy = (value: JsonContainer): JsonContainer => Array.isArray(value) ? [...value] : { ...value }
+
+const getMutatedPointers = (operation: Operation): string[] => {
+	switch (operation.op) {
+		case 'test':
+			return []
+		case 'move':
+			return [operation.from, operation.path]
+		default:
+			return [operation.path]
+	}
+}
+
+/**
+ * Applies the patch to a copy of `root`, leaving `root` untouched. Only the containers on the paths
+ * the patch writes to are copied; everything else stays shared with `root`.
+ */
+export const applyPatchCopyOnWrite = <T extends object>(root: T, patch: Operation[]): { result: T; errors: Error[] } => {
+	const result = { ...root }
+	const copies = new Set<unknown>([result])
+	const errors: Error[] = []
+	for (const operation of patch) {
+		// Each path is copied against the tree as the previous operations left it: array indices shift
+		// and `move` relocates an uncopied original, so a path resolved up front can miss the target.
+		for (const pointer of getMutatedPointers(operation)) {
+			copyParents(result, pointer, copies)
+		}
+		for (const error of applyPatch(result, [operation])) {
+			if (error !== null) {
+				errors.push(error)
+			}
+		}
+	}
+	return { result, errors }
+}
+
+const copyParents = (root: object, pointer: string, copies: Set<unknown>): void => {
+	const tokens = Pointer.fromJSON(pointer).tokens.slice(1)
+	// rfc6902 writes into the node reached before the last token, unless that token is skipped.
+	const lastToken = tokens.at(-1)
+	const writtenTokens = lastToken !== undefined && skippedTokens.has(lastToken) ? tokens : tokens.slice(0, -1)
+	const parentTokens = writtenTokens.filter(token => !skippedTokens.has(token))
+	let node: object = root
+	for (const token of parentTokens) {
+		const child: unknown = Reflect.get(node, token)
+		if (!isContainer(child)) {
+			return
+		}
+		const childCopy = copies.has(child) ? child : shallowCopy(child)
+		copies.add(childCopy)
+		Reflect.set(node, token, childCopy)
+		node = childCopy
+	}
+}

package/tests/cases/integration/createColumn.test.ts

@@ -229,3 +229,31 @@ describe('create numeric column', () =>
 		],
 		sql: SQL`ALTER TABLE "author" ADD "balance" numeric(20, 9);`,
 	}))
+
+describe('create a column with a collation', () =>
+	testMigrations({
+		original: createSchema({
+			Author: class Author {
+			},
+		}),
+		updated: createSchema({
+			Author: class Author {
+				name = def.stringColumn().collation('und-x-icu')
+			},
+		}),
+		diff: [
+			{
+				modification: 'createColumn',
+				entityName: 'Author',
+				field: {
+					columnName: 'name',
+					name: 'name',
+					nullable: true,
+					type: Model.ColumnType.String,
+					columnType: 'text',
+					collation: 'und-x-icu',
+				},
+			},
+		],
+		sql: SQL`ALTER TABLE "author" ADD "name" text COLLATE "und-x-icu";`,
+	}))

package/tests/cases/unit/patchAclSchemaModification.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, test } from 'bun:test'
+import { Acl, Schema } from '@contember/schema'
+import { emptySchema } from '@contember/schema-utils'
+import { createPatch } from 'rfc6902'
+import { ModificationHandlerFactory, SchemaMigrator } from '../../../src/index.js'
+
+const schemaMigrator = new SchemaMigrator(new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap))
+
+const role = (entityNames: string[]): Acl.RolePermissions => ({
+	variables: {},
+	stages: '*',
+	entities: Object.fromEntries(entityNames.map(name => [name, { predicates: {}, operations: { read: { id: true } } }])),
+})
+
+const schemaWithAcl = (): Schema => ({
+	...emptySchema,
+	acl: {
+		roles: {
+			editor: role(['Article', 'Tag']),
+			reader: role(['Article']),
+		},
+	},
+})
+
+describe('patchAclSchema', () => {
+	test('leaves the input schema untouched and shares the branches the patch does not write to', () => {
+		const schema = schemaWithAcl()
+		const snapshot = structuredClone(schema)
+
+		const result = schemaMigrator.applyModifications(schema, [{
+			modification: 'patchAclSchema',
+			patch: [
+				{ op: 'replace', path: '/roles/editor/entities/Article/operations/read/id', value: false },
+				{ op: 'remove', path: '/roles/editor/entities/Tag' },
+				{ op: 'add', path: '/roles/writer', value: role([]) },
+				{ op: 'add', path: '/roles/writer/entities/Article', value: { predicates: {}, operations: {} } },
+			],
+		}], 6)
+
+		expect(schema).toStrictEqual(snapshot)
+		expect(result.acl.roles.editor.entities).toStrictEqual({
+			Article: { predicates: {}, operations: { read: { id: false } } },
+		})
+		expect(result.acl.roles.writer.entities).toStrictEqual({ Article: { predicates: {}, operations: {} } })
+		expect(result.acl.roles.reader).toBe(schema.acl.roles.reader)
+	})
+
+	test('move copies both the source and the target parent', () => {
+		const schema = schemaWithAcl()
+		const snapshot = structuredClone(schema)
+
+		const result = schemaMigrator.applyModifications(schema, [{
+			modification: 'patchAclSchema',
+			patch: [{ op: 'move', from: '/roles/editor/entities/Tag', path: '/roles/reader/entities/Tag' }],
+		}], 6)
+
+		expect(schema).toStrictEqual(snapshot)
+		expect(Object.keys(result.acl.roles.editor.entities)).toStrictEqual(['Article'])
+		expect(Object.keys(result.acl.roles.reader.entities)).toStrictEqual(['Article', 'Tag'])
+	})
+
+	test('does not keep a reference to the patch values', () => {
+		const value = role(['Article'])
+		const modification = { modification: 'patchAclSchema', patch: [{ op: 'add', path: '/roles/writer', value }] }
+
+		const first = schemaMigrator.applyModifications(schemaWithAcl(), [modification], 6)
+		schemaMigrator.applyModifications(first, [{
+			modification: 'patchAclSchema',
+			patch: [{ op: 'remove', path: '/roles/writer/entities/Article' }],
+		}], 6)
+
+		expect(value).toStrictEqual(role(['Article']))
+		expect(first.acl.roles.writer.entities).toStrictEqual(role(['Article']).entities)
+	})
+
+	test('follows array indices that earlier operations of the patch shifted', () => {
+		const withPredicate = (predicate: Acl.PredicateDefinition): Schema => ({
+			...emptySchema,
+			acl: { roles: { editor: { ...role(['Article']), entities: { Article: { predicates: { p: predicate }, operations: {} } } } } },
+		})
+		const schema = withPredicate({ or: [{ a: { eq: 1 } }, { b: { eq: 2 } }, { c: { eq: 3, isNull: false } }] })
+		const target = withPredicate({ or: [{ b: { eq: 2 } }, { c: { eq: 3 } }] })
+		const snapshot = structuredClone(schema)
+
+		const result = schemaMigrator.applyModifications(schema, [{
+			modification: 'patchAclSchema',
+			patch: createPatch(schema.acl, target.acl),
+		}], 6)
+
+		expect(schema).toStrictEqual(snapshot)
+		expect(result.acl).toStrictEqual(target.acl)
+	})
+
+	test('copies a moved subtree before writing into it', () => {
+		const schema = schemaWithAcl()
+		const snapshot = structuredClone(schema)
+
+		const result = schemaMigrator.applyModifications(schema, [{
+			modification: 'patchAclSchema',
+			patch: [
+				{ op: 'move', from: '/roles/editor', path: '/roles/writer' },
+				{ op: 'remove', path: '/roles/writer/entities/Tag' },
+			],
+		}], 6)
+
+		expect(schema).toStrictEqual(snapshot)
+		expect(Object.keys(result.acl.roles.writer.entities)).toStrictEqual(['Article'])
+	})
+
+	test('replaying the same migrations twice gives the same schema', () => {
+		const modifications = [
+			{ modification: 'updateAclSchema', schema: { roles: { editor: role(['Article', 'Tag']) } } },
+			{
+				modification: 'patchAclSchema',
+				patch: [
+					{ op: 'move', from: '/roles/editor', path: '/roles/writer' },
+					{ op: 'remove', path: '/roles/writer/entities/Tag' },
+				],
+			},
+		]
+
+		const first = schemaMigrator.applyModifications(emptySchema, modifications, 6)
+		const second = schemaMigrator.applyModifications(emptySchema, modifications, 6)
+
+		expect(second).toStrictEqual(first)
+	})
+
+	test('skips the tokens rfc6902 skips when copying', () => {
+		const schema = schemaWithAcl()
+		const snapshot = structuredClone(schema)
+
+		schemaMigrator.applyModifications(schema, [{
+			modification: 'patchAclSchema',
+			patch: [
+				{ op: 'replace', path: '/roles/editor/__proto__/entities/Article/operations/read/id', value: false },
+				{ op: 'add', path: '/roles/constructor/reader/entities/Tag', value: {} },
+				{ op: 'add', path: '/roles/reader/__proto__', value: { injected: true } },
+			],
+		}], 6)
+
+		expect(schema).toStrictEqual(snapshot)
+		expect(Object.getPrototypeOf(schema.acl.roles.reader)).toBe(Object.prototype)
+	})
+})