|
6 | 6 | extension PrimaryKeyedTable { |
7 | 7 | static func metadataTriggers( |
8 | 8 | parentForeignKey: ForeignKey?, |
9 | | - defaultZone: CKRecordZone |
| 9 | + defaultZone: CKRecordZone, |
| 10 | + privateTables: [any SynchronizableTable] |
10 | 11 | ) -> [TemporaryTrigger<Self>] { |
11 | 12 | [ |
12 | | - afterInsert(parentForeignKey: parentForeignKey, defaultZone: defaultZone), |
13 | | - afterUpdate(parentForeignKey: parentForeignKey, defaultZone: defaultZone), |
14 | | - afterDeleteFromUser(parentForeignKey: parentForeignKey, defaultZone: defaultZone), |
| 13 | + afterInsert( |
| 14 | + parentForeignKey: parentForeignKey, |
| 15 | + defaultZone: defaultZone, |
| 16 | + privateTables: privateTables |
| 17 | + ), |
| 18 | + afterUpdate( |
| 19 | + parentForeignKey: parentForeignKey, |
| 20 | + defaultZone: defaultZone, |
| 21 | + privateTables: privateTables |
| 22 | + ), |
| 23 | + afterDeleteFromUser( |
| 24 | + parentForeignKey: parentForeignKey, |
| 25 | + defaultZone: defaultZone, |
| 26 | + privateTables: privateTables |
| 27 | + ), |
15 | 28 | afterDeleteFromSyncEngine, |
16 | | - afterPrimaryKeyChange(parentForeignKey: parentForeignKey, defaultZone: defaultZone), |
| 29 | + afterPrimaryKeyChange( |
| 30 | + parentForeignKey: parentForeignKey, |
| 31 | + defaultZone: defaultZone, |
| 32 | + privateTables: privateTables |
| 33 | + ), |
17 | 34 | ] |
18 | 35 | } |
19 | 36 |
|
20 | 37 | fileprivate static func afterPrimaryKeyChange( |
21 | 38 | parentForeignKey: ForeignKey?, |
22 | | - defaultZone: CKRecordZone |
| 39 | + defaultZone: CKRecordZone, |
| 40 | + privateTables: [any SynchronizableTable] |
23 | 41 | ) -> TemporaryTrigger<Self> { |
24 | 42 | createTemporaryTrigger( |
25 | 43 | "\(String.sqliteDataCloudKitSchemaName)_after_primary_key_change_on_\(tableName)", |
|
28 | 46 | checkWritePermissions( |
29 | 47 | alias: new, |
30 | 48 | parentForeignKey: parentForeignKey, |
31 | | - defaultZone: defaultZone |
| 49 | + defaultZone: defaultZone, |
| 50 | + privateTables: privateTables |
32 | 51 | ) |
33 | 52 | SyncMetadata |
34 | 53 | .where { |
|
44 | 63 |
|
45 | 64 | fileprivate static func afterInsert( |
46 | 65 | parentForeignKey: ForeignKey?, |
47 | | - defaultZone: CKRecordZone |
| 66 | + defaultZone: CKRecordZone, |
| 67 | + privateTables: [any SynchronizableTable] |
48 | 68 | ) -> TemporaryTrigger<Self> { |
49 | 69 | createTemporaryTrigger( |
50 | 70 | "\(String.sqliteDataCloudKitSchemaName)_after_insert_on_\(tableName)", |
|
53 | 73 | checkWritePermissions( |
54 | 74 | alias: new, |
55 | 75 | parentForeignKey: parentForeignKey, |
56 | | - defaultZone: defaultZone |
| 76 | + defaultZone: defaultZone, |
| 77 | + privateTables: privateTables |
57 | 78 | ) |
58 | 79 | SyncMetadata.insert( |
59 | 80 | new: new, |
60 | 81 | parentForeignKey: parentForeignKey, |
61 | | - defaultZone: defaultZone |
| 82 | + defaultZone: defaultZone, |
| 83 | + privateTables: privateTables |
62 | 84 | ) |
63 | 85 | } |
64 | 86 | ) |
65 | 87 | } |
66 | 88 |
|
67 | 89 | fileprivate static func afterUpdate( |
68 | 90 | parentForeignKey: ForeignKey?, |
69 | | - defaultZone: CKRecordZone |
| 91 | + defaultZone: CKRecordZone, |
| 92 | + privateTables: [any SynchronizableTable] |
70 | 93 | ) -> TemporaryTrigger<Self> { |
71 | 94 | createTemporaryTrigger( |
72 | 95 | "\(String.sqliteDataCloudKitSchemaName)_after_update_on_\(tableName)", |
|
75 | 98 | checkWritePermissions( |
76 | 99 | alias: new, |
77 | 100 | parentForeignKey: parentForeignKey, |
78 | | - defaultZone: defaultZone |
| 101 | + defaultZone: defaultZone, |
| 102 | + privateTables: privateTables |
79 | 103 | ) |
80 | 104 | SyncMetadata.insert( |
81 | 105 | new: new, |
82 | 106 | parentForeignKey: parentForeignKey, |
83 | | - defaultZone: defaultZone |
| 107 | + defaultZone: defaultZone, |
| 108 | + privateTables: privateTables |
84 | 109 | ) |
85 | 110 | SyncMetadata.update( |
86 | 111 | new: new, |
87 | 112 | parentForeignKey: parentForeignKey, |
88 | | - defaultZone: defaultZone |
| 113 | + defaultZone: defaultZone, |
| 114 | + privateTables: privateTables |
89 | 115 | ) |
90 | 116 | } |
91 | 117 | ) |
92 | 118 | } |
93 | 119 |
|
94 | 120 | fileprivate static func afterDeleteFromUser( |
95 | 121 | parentForeignKey: ForeignKey?, |
96 | | - defaultZone: CKRecordZone |
| 122 | + defaultZone: CKRecordZone, |
| 123 | + privateTables: [any SynchronizableTable] |
97 | 124 | ) -> TemporaryTrigger< |
98 | 125 | Self |
99 | 126 | > { |
|
104 | 131 | checkWritePermissions( |
105 | 132 | alias: old, |
106 | 133 | parentForeignKey: parentForeignKey, |
107 | | - defaultZone: defaultZone |
| 134 | + defaultZone: defaultZone, |
| 135 | + privateTables: privateTables |
108 | 136 | ) |
109 | 137 | SyncMetadata |
110 | 138 | .where { |
|
141 | 169 | fileprivate static func insert<T: PrimaryKeyedTable, Name>( |
142 | 170 | new: StructuredQueriesCore.TableAlias<T, Name>.TableColumns, |
143 | 171 | parentForeignKey: ForeignKey?, |
144 | | - defaultZone: CKRecordZone |
| 172 | + defaultZone: CKRecordZone, |
| 173 | + privateTables: [any SynchronizableTable] |
145 | 174 | ) -> some StructuredQueriesCore.Statement { |
146 | 175 | let (parentRecordPrimaryKey, parentRecordType, zoneName, ownerName) = parentFields( |
147 | 176 | alias: new, |
148 | 177 | parentForeignKey: parentForeignKey, |
149 | | - defaultZone: defaultZone |
| 178 | + defaultZone: defaultZone, |
| 179 | + privateTables: privateTables |
150 | 180 | ) |
151 | 181 | let defaultZoneName = #sql( |
152 | 182 | "\(quote: defaultZone.zoneID.zoneName, delimiter: .text)", |
|
181 | 211 | fileprivate static func update<T: PrimaryKeyedTable, Name>( |
182 | 212 | new: StructuredQueriesCore.TableAlias<T, Name>.TableColumns, |
183 | 213 | parentForeignKey: ForeignKey?, |
184 | | - defaultZone: CKRecordZone |
| 214 | + defaultZone: CKRecordZone, |
| 215 | + privateTables: [any SynchronizableTable] |
185 | 216 | ) -> some StructuredQueriesCore.Statement { |
186 | 217 | let (parentRecordPrimaryKey, parentRecordType, zoneName, ownerName) = parentFields( |
187 | 218 | alias: new, |
188 | 219 | parentForeignKey: parentForeignKey, |
189 | | - defaultZone: defaultZone |
| 220 | + defaultZone: defaultZone, |
| 221 | + privateTables: privateTables |
190 | 222 | ) |
191 | 223 | return Self.where { |
192 | 224 | $0.recordPrimaryKey.eq(#sql("\(new.primaryKey)")) |
|
322 | 354 | private func parentFields<Base, Name>( |
323 | 355 | alias: StructuredQueriesCore.TableAlias<Base, Name>.TableColumns, |
324 | 356 | parentForeignKey: ForeignKey?, |
325 | | - defaultZone: CKRecordZone |
| 357 | + defaultZone: CKRecordZone, |
| 358 | + privateTables: [any SynchronizableTable] |
326 | 359 | ) -> ( |
327 | 360 | parentRecordPrimaryKey: SQLQueryExpression<String>?, |
328 | 361 | parentRecordType: SQLQueryExpression<String>?, |
329 | 362 | zoneName: SQLQueryExpression<String?>, |
330 | 363 | ownerName: SQLQueryExpression<String?> |
331 | 364 | ) { |
332 | | - return |
333 | | - parentForeignKey |
| 365 | + let zoneNameOverride: SQLQueryExpression<String?> |
| 366 | + let ownerNameOverride: SQLQueryExpression<String?> |
| 367 | + if privateTables.contains(where: { $0.base.tableName == Base.tableName }) { |
| 368 | + zoneNameOverride = #sql("\(quote: defaultZone.zoneID.zoneName, delimiter: .text)") |
| 369 | + ownerNameOverride = #sql("\(quote: defaultZone.zoneID.ownerName, delimiter: .text)") |
| 370 | + } else { |
| 371 | + zoneNameOverride = #sql("NULL") |
| 372 | + ownerNameOverride = #sql("NULL") |
| 373 | + } |
| 374 | + return parentForeignKey |
334 | 375 | .map { foreignKey in |
335 | 376 | let parentRecordPrimaryKey = #sql( |
336 | 377 | #"\#(type(of: alias).QueryValue.self).\#(quote: foreignKey.from)"#, |
|
344 | 385 | return ( |
345 | 386 | parentRecordPrimaryKey, |
346 | 387 | parentRecordType, |
347 | | - #sql("coalesce(\($currentZoneName()), (\(parentMetadata.select(\.zoneName))))"), |
348 | | - #sql("coalesce(\($currentOwnerName()), (\(parentMetadata.select(\.ownerName))))") |
| 388 | + #sql("coalesce(\(zoneNameOverride), \($currentZoneName()), (\(parentMetadata.select(\.zoneName))))"), |
| 389 | + #sql("coalesce(\(ownerNameOverride), \($currentOwnerName()), (\(parentMetadata.select(\.ownerName))))") |
349 | 390 | ) |
350 | 391 | } |
351 | 392 | ?? ( |
|
373 | 414 | private func checkWritePermissions<Base, Name>( |
374 | 415 | alias: StructuredQueriesCore.TableAlias<Base, Name>.TableColumns, |
375 | 416 | parentForeignKey: ForeignKey?, |
376 | | - defaultZone: CKRecordZone |
| 417 | + defaultZone: CKRecordZone, |
| 418 | + privateTables: [any SynchronizableTable] |
377 | 419 | ) -> some StructuredQueriesCore.Statement<Never> { |
378 | 420 | let (parentRecordPrimaryKey, parentRecordType, _, _) = parentFields( |
379 | 421 | alias: alias, |
380 | 422 | parentForeignKey: parentForeignKey, |
381 | | - defaultZone: defaultZone |
| 423 | + defaultZone: defaultZone, |
| 424 | + privateTables: privateTables |
382 | 425 | ) |
383 | 426 |
|
384 | 427 | return With { |
|
0 commit comments