@starci/eslint-canon-be 3.8.20 → 3.9.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +16 -0
- package/package.json +1 -1
- package/runtime/bundle.json +192 -0
- package/runtime/engine/by-code-unit.mjs +6 -6
- package/runtime/engine/model-config.mjs +98 -76
- package/runtime/engine/orca-config.mjs +22 -17
- package/runtime/engine/release-config.mjs +22 -18
- package/runtime/engine/removed-vocabulary.mjs +21 -20
- package/runtime/engine/resources-config.mjs +42 -35
- package/runtime/engine/runtime-root.mjs +11 -13
- package/runtime/engine/secrets.mjs +170 -102
- package/runtime/engine/sonar-config.mjs +16 -13
- package/runtime/engine/temp-root.mjs +3 -9
- package/runtime/knowledge/hfs/canon-pins.yaml +10 -10
- package/runtime/knowledge/hfs/rules.yaml +6 -6
- package/runtime/knowledge/hfs/slots.yaml +2 -2
- package/runtime/knowledge/sonar-gate.yaml +1 -1
- package/runtime/packages/hfs/templates/app/package-scripts/package.json +1 -1
- package/runtime/scripts/api/git/cat-file.mjs +0 -1
- package/runtime/scripts/api/git/config-get.mjs +1 -2
- package/runtime/scripts/api/git/diff.mjs +0 -1
- package/runtime/scripts/api/git/lib.mjs +32 -32
- package/runtime/scripts/api/git/ls-files.mjs +0 -1
- package/runtime/scripts/api/git/ls-tree.mjs +0 -1
- package/runtime/scripts/api/git/merge-base.mjs +2 -3
- package/runtime/scripts/api/git/remote.mjs +0 -1
- package/runtime/scripts/api/git/rev-parse-query.mjs +0 -1
- package/runtime/scripts/api/git/show.mjs +0 -1
- package/runtime/scripts/hfs/allows.mjs +37 -38
- package/runtime/scripts/hfs/architecture/ast-walks.mjs +180 -163
- package/runtime/scripts/hfs/architecture/automatic-gates.mjs +80 -73
- package/runtime/scripts/hfs/architecture/backend-app-files.mjs +88 -77
- package/runtime/scripts/hfs/architecture/backend.mjs +378 -357
- package/runtime/scripts/hfs/architecture/background-unowned.mjs +201 -187
- package/runtime/scripts/hfs/architecture/canon-clones.mjs +260 -209
- package/runtime/scripts/hfs/architecture/canon-jsx-clones.mjs +149 -116
- package/runtime/scripts/hfs/architecture/client-reaches-server.mjs +72 -68
- package/runtime/scripts/hfs/architecture/clones.mjs +212 -217
- package/runtime/scripts/hfs/architecture/config-unread.mjs +7 -9
- package/runtime/scripts/hfs/architecture/config.mjs +302 -268
- package/runtime/scripts/hfs/architecture/connection-map.mjs +258 -225
- package/runtime/scripts/hfs/architecture/constructor-deps.mjs +80 -71
- package/runtime/scripts/hfs/architecture/context-coupling.mjs +82 -77
- package/runtime/scripts/hfs/architecture/context-map.mjs +267 -234
- package/runtime/scripts/hfs/architecture/context-owner.mjs +73 -61
- package/runtime/scripts/hfs/architecture/context-platform-tables.mjs +47 -43
- package/runtime/scripts/hfs/architecture/context-transaction.mjs +54 -52
- package/runtime/scripts/hfs/architecture/contract-fixture-guard.mjs +113 -104
- package/runtime/scripts/hfs/architecture/contracts-readonly.mjs +288 -270
- package/runtime/scripts/hfs/architecture/contracts.mjs +408 -393
- package/runtime/scripts/hfs/architecture/cross-app-duplicate.mjs +50 -51
- package/runtime/scripts/hfs/architecture/dead-exports-bindings.mjs +143 -119
- package/runtime/scripts/hfs/architecture/dead-exports.mjs +286 -228
- package/runtime/scripts/hfs/architecture/default-deny.mjs +129 -110
- package/runtime/scripts/hfs/architecture/doc-language.mjs +24 -19
- package/runtime/scripts/hfs/architecture/entity-registry.mjs +20 -22
- package/runtime/scripts/hfs/architecture/entrypoint.mjs +47 -45
- package/runtime/scripts/hfs/architecture/error-codes.mjs +37 -35
- package/runtime/scripts/hfs/architecture/error-masked.mjs +55 -59
- package/runtime/scripts/hfs/architecture/fe-slot-allows.mjs +24 -23
- package/runtime/scripts/hfs/architecture/feature-shape.mjs +40 -38
- package/runtime/scripts/hfs/architecture/framework-pinned.mjs +21 -21
- package/runtime/scripts/hfs/architecture/frontend-block-render.mjs +106 -98
- package/runtime/scripts/hfs/architecture/frontend-grammar.mjs +153 -150
- package/runtime/scripts/hfs/architecture/frontend-routing.mjs +161 -149
- package/runtime/scripts/hfs/architecture/frontend-world-render.mjs +343 -305
- package/runtime/scripts/hfs/architecture/frontend-world.mjs +340 -294
- package/runtime/scripts/hfs/architecture/frontend.mjs +174 -184
- package/runtime/scripts/hfs/architecture/function-spec-providers.mjs +124 -106
- package/runtime/scripts/hfs/architecture/hfs-graph.mjs +52 -48
- package/runtime/scripts/hfs/architecture/hooks-are-hooks.mjs +81 -71
- package/runtime/scripts/hfs/architecture/i18n-keys.mjs +155 -141
- package/runtime/scripts/hfs/architecture/identity.mjs +141 -125
- package/runtime/scripts/hfs/architecture/index.mjs +272 -272
- package/runtime/scripts/hfs/architecture/injection-token-exported.mjs +45 -43
- package/runtime/scripts/hfs/architecture/jwt-ast.mjs +195 -176
- package/runtime/scripts/hfs/architecture/machine-ast.mjs +163 -155
- package/runtime/scripts/hfs/architecture/managed-scripts.mjs +19 -20
- package/runtime/scripts/hfs/architecture/module-per-transport.mjs +177 -172
- package/runtime/scripts/hfs/architecture/next-data-contract.mjs +100 -78
- package/runtime/scripts/hfs/architecture/next-data-inference.mjs +170 -154
- package/runtime/scripts/hfs/architecture/next-data-key.mjs +311 -275
- package/runtime/scripts/hfs/architecture/next-data-symbols.mjs +17 -17
- package/runtime/scripts/hfs/architecture/next-data.mjs +351 -334
- package/runtime/scripts/hfs/architecture/operation-contract-roots.mjs +39 -37
- package/runtime/scripts/hfs/architecture/owners.mjs +97 -98
- package/runtime/scripts/hfs/architecture/package-shape.mjs +56 -55
- package/runtime/scripts/hfs/architecture/presentation.mjs +138 -130
- package/runtime/scripts/hfs/architecture/reachability.mjs +258 -241
- package/runtime/scripts/hfs/architecture/register-once.mjs +152 -139
- package/runtime/scripts/hfs/architecture/registration.mjs +301 -267
- package/runtime/scripts/hfs/architecture/required-files.mjs +172 -167
- package/runtime/scripts/hfs/architecture/route-files-thin.mjs +85 -77
- package/runtime/scripts/hfs/architecture/schema-owner.mjs +206 -181
- package/runtime/scripts/hfs/architecture/server-action.mjs +48 -48
- package/runtime/scripts/hfs/architecture/side-boundary.mjs +2 -5
- package/runtime/scripts/hfs/architecture/source-names-shape.mjs +261 -259
- package/runtime/scripts/hfs/architecture/source-names.mjs +304 -278
- package/runtime/scripts/hfs/architecture/sql-keys.mjs +277 -194
- package/runtime/scripts/hfs/architecture/sql-owner.mjs +236 -194
- package/runtime/scripts/hfs/architecture/sql-returning.mjs +46 -45
- package/runtime/scripts/hfs/architecture/sql-token-forms.mjs +86 -74
- package/runtime/scripts/hfs/architecture/sql-tokens.mjs +456 -341
- package/runtime/scripts/hfs/architecture/staged-consumers.mjs +35 -30
- package/runtime/scripts/hfs/architecture/surface.mjs +64 -74
- package/runtime/scripts/hfs/architecture/symbols.mjs +209 -216
- package/runtime/scripts/hfs/architecture/test-world-files.mjs +165 -155
- package/runtime/scripts/hfs/architecture/tiers.mjs +161 -154
- package/runtime/scripts/hfs/architecture/transport-owner.mjs +155 -149
- package/runtime/scripts/hfs/architecture/type-context.mjs +255 -250
- package/runtime/scripts/hfs/architecture/typescript.mjs +358 -318
- package/runtime/scripts/hfs/architecture/unit-spec-providers.mjs +110 -92
- package/runtime/scripts/hfs/declaration-shape.mjs +140 -103
- package/runtime/scripts/hfs/declaration-slots.mjs +64 -61
- package/runtime/scripts/hfs/edition-slots.mjs +43 -40
- package/runtime/scripts/hfs/linear-text.mjs +20 -20
- package/runtime/scripts/hfs/param-names.mjs +6 -11
- package/runtime/scripts/hfs/path-findings.mjs +120 -100
- package/runtime/scripts/hfs/repo-identity.mjs +55 -42
- package/runtime/scripts/hfs/rule-catalog.mjs +353 -257
- package/runtime/scripts/hfs/rule-params-shape.mjs +60 -47
- package/runtime/scripts/hfs/rules/database-migrations.mjs +428 -388
- package/runtime/scripts/hfs/rules/fe-no-tests.mjs +37 -36
- package/runtime/scripts/hfs/rules/read.mjs +19 -15
- package/runtime/scripts/hfs/rules/secrets.mjs +1 -1
- package/runtime/scripts/hfs/rules/spec-placement.mjs +12 -13
- package/runtime/scripts/hfs/slot-app-view.mjs +69 -74
- package/runtime/scripts/hfs/slot-classify.mjs +42 -38
- package/runtime/scripts/hfs/slot-errors.mjs +8 -7
- package/runtime/scripts/hfs/slot-imports.mjs +70 -63
- package/runtime/scripts/hfs/slot-manifest-shape.mjs +74 -52
- package/runtime/scripts/hfs/slot-match.mjs +122 -111
- package/runtime/scripts/hfs/slot-path.mjs +0 -2
- package/runtime/scripts/hfs/slot-required.mjs +65 -59
- package/runtime/scripts/hfs/slot-semantic-problems.mjs +138 -112
- package/runtime/scripts/hfs/slot-side-problems.mjs +23 -19
- package/runtime/scripts/hfs/slots.mjs +175 -152
- package/runtime/scripts/hfs/test-world-slot.mjs +0 -1
- package/runtime/scripts/hfs/trailing-slashes.mjs +4 -4
- package/runtime/scripts/hfs/typescript-programs.mjs +66 -69
- package/runtime/scripts/hfs/view.mjs +38 -40
- package/runtime/scripts/lib/dockerfile.mjs +131 -114
- package/runtime/scripts/lib/env.mjs +3 -6
- package/runtime/scripts/lib/event-contract.mjs +73 -78
- package/runtime/scripts/lib/git.mjs +15 -16
- package/runtime/scripts/lib/glob.mjs +23 -14
- package/runtime/scripts/lib/grammar-lint.mjs +33 -37
- package/runtime/scripts/lib/i18n.mjs +32 -35
- package/runtime/scripts/lib/in-order.mjs +57 -38
- package/runtime/scripts/lib/json-clone.mjs +45 -36
- package/runtime/scripts/lib/json.mjs +26 -14
- package/runtime/scripts/lib/language.mjs +133 -129
- package/runtime/scripts/lib/list.mjs +9 -14
- package/runtime/scripts/lib/mutation-fence.mjs +10 -5
- package/runtime/scripts/lib/path-key.mjs +53 -38
- package/runtime/scripts/lib/read-text.mjs +30 -17
- package/runtime/scripts/lib/regex.mjs +1 -2
- package/runtime/scripts/lib/same-text.mjs +0 -1
- package/runtime/scripts/lib/sops-envelope.mjs +148 -120
- package/runtime/scripts/lib/stack-services.mjs +128 -129
- package/runtime/scripts/lib/ts-analysis.mjs +28 -26
- package/runtime/scripts/lib/ts-ast.mjs +36 -42
- package/runtime/scripts/lib/walk.mjs +33 -27
- package/runtime/scripts/lib/yaml-cached.mjs +4 -4
|
@@ -13,135 +13,136 @@ import { fileURLToPath } from 'node:url';
|
|
|
13
13
|
import { loadTypescript } from '../../lib/package-at.mjs';
|
|
14
14
|
import { isConstVariable } from '../../lib/ts-ast.mjs';
|
|
15
15
|
import { lexicalChecker, unwrapExpression } from '../../lib/ts-analysis.mjs';
|
|
16
|
-
|
|
17
16
|
const HERE = path.dirname(fileURLToPath(import.meta.url));
|
|
18
17
|
const MIGRATION_PLAIN = /[a-z0-9]+(?:-[a-z0-9]+)*/;
|
|
19
18
|
const MIGRATION_CONTRACT_TAIL = /contract_[a-z0-9]+(?:[-_][a-z0-9]+)*/;
|
|
20
19
|
const MIGRATION_SLUG = [MIGRATION_PLAIN.source, MIGRATION_CONTRACT_TAIL.source, `${MIGRATION_PLAIN.source}_${MIGRATION_CONTRACT_TAIL.source}`].join('|');
|
|
21
|
-
const MIGRATION_NAME = new RegExp(String.raw`^(\d{14})_(${MIGRATION_SLUG})\.sql$`);
|
|
20
|
+
const MIGRATION_NAME = new RegExp(String.raw `^(\d{14})_(${MIGRATION_SLUG})\.sql$`);
|
|
22
21
|
export const isMigrationName = (name) => MIGRATION_NAME.test(name);
|
|
23
22
|
const RESTAMP_HEADER = /^-- starci:restamp (\d{14}) (\d{14})(?:\r?\n|$)/;
|
|
24
23
|
const withoutRestampHeader = (text) => text?.replace(RESTAMP_HEADER, '') ?? null;
|
|
25
|
-
|
|
26
24
|
/** `<ts14>` -> the UTC instant it names, or null when the digits are no real time (month 13, day 32, ...). */
|
|
27
25
|
export function migrationStamp(text) {
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
26
|
+
const [year, month, day, hour, minute, second] = [Number(text.slice(0, 4)), ...[4, 6, 8, 10, 12].map((at) => Number(text.slice(at, at + 2)))];
|
|
27
|
+
const stamp = Date.UTC(year, month - 1, day, hour, minute, second);
|
|
28
|
+
const date = new Date(stamp);
|
|
29
|
+
return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day
|
|
30
|
+
&& date.getUTCHours() === hour && date.getUTCMinutes() === minute && date.getUTCSeconds() === second ? stamp : null;
|
|
33
31
|
}
|
|
34
|
-
|
|
35
32
|
/** The three git reads L02 makes: (args, {cwd}) -> {ok, stdout}. */
|
|
36
33
|
export function defaultGit(args, { cwd }) {
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
34
|
+
const [verb, ...rest] = args;
|
|
35
|
+
const env = withoutGitLocalEnv(process.env);
|
|
36
|
+
if (verb === 'merge-base') {
|
|
37
|
+
const sha = mergeBase(cwd, rest[0], rest[1]);
|
|
38
|
+
return { ok: sha !== null, stdout: sha ?? '' };
|
|
39
|
+
}
|
|
40
|
+
let call = show;
|
|
41
|
+
if (verb === 'ls-tree')
|
|
42
|
+
call = lsTree;
|
|
43
|
+
const result = call(rest, { cwd, env, maxBuffer: 64 * 1024 * 1024 });
|
|
44
|
+
return { ok: !result.error && result.status === 0, stdout: result.stdout };
|
|
45
|
+
}
|
|
46
46
|
const runGit = (git, repoRoot, args) => Promise.resolve(git(args, { cwd: repoRoot }))
|
|
47
|
-
|
|
48
|
-
|
|
47
|
+
.then((result) => ({ ok: result?.ok === true, stdout: String(result?.stdout ?? '') }));
|
|
49
48
|
async function baseShaOf(git, repoRoot, base) {
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
49
|
+
let found = null;
|
|
50
|
+
await findInOrder(base ? [base] : ['origin/main', 'main'], async (ref) => {
|
|
51
|
+
const result = await runGit(git, repoRoot, ['merge-base', 'HEAD', ref]);
|
|
52
|
+
if (result.ok && result.stdout.trim())
|
|
53
|
+
found = { ref, sha: result.stdout.trim() };
|
|
54
|
+
return found !== null;
|
|
55
|
+
});
|
|
56
|
+
return found;
|
|
57
|
+
}
|
|
59
58
|
async function migrationFilesAt(git, repoRoot, sha) {
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
59
|
+
const result = await runGit(git, repoRoot, ['ls-tree', '-r', '--name-only', '-z', sha, '--', MIGRATIONS_DIR]);
|
|
60
|
+
if (!result.ok)
|
|
61
|
+
return [];
|
|
62
|
+
const prefix = `${MIGRATIONS_DIR}/`;
|
|
63
|
+
return result.stdout.split('\0').filter((entry) => entry.startsWith(prefix));
|
|
64
64
|
}
|
|
65
|
-
|
|
66
65
|
async function baseFileText(git, repoRoot, sha, file) {
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
66
|
+
// `./` reads the path from the app root, which is a folder of a larger repository when the app is nested in one (an example of the runtime).
|
|
67
|
+
const result = await runGit(git, repoRoot, ['show', `${sha}:./${file}`]);
|
|
68
|
+
return result.ok ? result.stdout : null;
|
|
70
69
|
}
|
|
71
|
-
|
|
72
70
|
function localMigrationFindings(local) {
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
71
|
+
const findings = [];
|
|
72
|
+
const stamps = new Map();
|
|
73
|
+
for (const entry of local) {
|
|
74
|
+
if (!entry.match) {
|
|
75
|
+
findings.push(found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} is not named <ts14>_<kebab>.sql; a migration is created by \`npm run db:new\` (starci app db new), never renamed by hand`, { expected: '<ts14>_<kebab>.sql' }));
|
|
76
|
+
continue;
|
|
77
|
+
}
|
|
78
|
+
const stamp = migrationStamp(entry.match[1]);
|
|
79
|
+
if (stamp === null) {
|
|
80
|
+
findings.push(found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} carries ${entry.match[1]}, which is no valid UTC time; a migration stamp must name a valid UTC instant`, { stamp: entry.match[1] }));
|
|
81
|
+
continue;
|
|
82
|
+
}
|
|
83
|
+
if (stamps.has(stamp))
|
|
84
|
+
findings.push(found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} shares stamp ${entry.match[1]} with ${stamps.get(stamp)}; stamps are strictly increasing`, { stamp: entry.match[1], other: stamps.get(stamp) }));
|
|
85
|
+
stamps.set(stamp, entry.file);
|
|
79
86
|
}
|
|
80
|
-
|
|
81
|
-
if (stamp === null) {
|
|
82
|
-
findings.push(found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} carries ${entry.match[1]}, which is no valid UTC time; a migration stamp must name a valid UTC instant`, { stamp: entry.match[1] }));
|
|
83
|
-
continue;
|
|
84
|
-
}
|
|
85
|
-
if (stamps.has(stamp)) findings.push(found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} shares stamp ${entry.match[1]} with ${stamps.get(stamp)}; stamps are strictly increasing`, { stamp: entry.match[1], other: stamps.get(stamp) }));
|
|
86
|
-
stamps.set(stamp, entry.file);
|
|
87
|
-
}
|
|
88
|
-
return findings;
|
|
87
|
+
return findings;
|
|
89
88
|
}
|
|
90
|
-
|
|
91
89
|
/** HEAD owns the append boundary. Archived names retire the old chain, so a replacement baseline starts afresh. */
|
|
92
90
|
function migrationHistory(files, retired, localNames) {
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
91
|
+
const prefix = `${MIGRATIONS_DIR}/`;
|
|
92
|
+
const onHead = new Set(files.filter(isActiveMigration).map((file) => file.slice(prefix.length)));
|
|
93
|
+
const retiredNames = new Set([...retired, ...files.filter((file) => file.startsWith(`${MIGRATIONS_ARCHIVE_DIR}/`)).map((file) => file.slice(MIGRATIONS_ARCHIVE_DIR.length + 1))].filter((name) => !localNames.has(name)));
|
|
94
|
+
const stamps = [...onHead].filter((name) => !retiredNames.has(name)).map((name) => MIGRATION_NAME.exec(name)?.[1]).filter((stamp) => Boolean(stamp)).map(migrationStamp).filter((stamp) => stamp !== null);
|
|
95
|
+
return { onHead, latest: stamps.length ? Math.max(...stamps) : null };
|
|
98
96
|
}
|
|
99
|
-
|
|
100
97
|
function migrationOrderingFindings(local, history, restamped = new Set()) {
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
98
|
+
return local.flatMap((entry) => {
|
|
99
|
+
const stamp = entry.match ? migrationStamp(entry.match[1]) : null;
|
|
100
|
+
if (history.onHead.has(entry.name) || restamped.has(entry.name) || stamp === null || history.latest === null || stamp > history.latest)
|
|
101
|
+
return [];
|
|
102
|
+
return [found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} is stamped ${entry.match[1]}, not after every migration already in repository history (latest active ${new Date(history.latest).toISOString()}); a new migration sorts after the committed active chain`, { stamp: entry.match[1], latest: new Date(history.latest).toISOString() })];
|
|
103
|
+
});
|
|
106
104
|
}
|
|
107
|
-
|
|
108
105
|
/** A restamp changes only the version, and its header proves the explicit old->new map against repository SQL. */
|
|
109
106
|
async function verifiedRestamps(local, files, repoRoot, git, sha) {
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
107
|
+
const prefix = `${MIGRATIONS_DIR}/`;
|
|
108
|
+
const active = files.filter(isActiveMigration).map((file) => file.slice(prefix.length));
|
|
109
|
+
const claims = local.map((entry) => ({ ...entry, header: RESTAMP_HEADER.exec(readText(repoRoot, entry.file) ?? '') })).filter((entry) => entry.header);
|
|
110
|
+
const accepted = [];
|
|
111
|
+
await eachInOrder(claims, async (entry) => {
|
|
112
|
+
const [, oldStamp, newStamp] = entry.header;
|
|
113
|
+
if (!entry.match || entry.match[1] !== newStamp || migrationStamp(oldStamp) === null || oldStamp === newStamp)
|
|
114
|
+
return;
|
|
115
|
+
if (claims.filter((claim) => claim.header[1] === oldStamp).length !== 1)
|
|
116
|
+
return;
|
|
117
|
+
const names = active.filter((name) => name.startsWith(`${oldStamp}_`) && name.slice(14) === entry.name.slice(14));
|
|
118
|
+
if (names.length !== 1 || local.some((candidate) => candidate.name === names[0]))
|
|
119
|
+
return;
|
|
120
|
+
const committed = await baseFileText(git, repoRoot, sha, `${prefix}${names[0]}`);
|
|
121
|
+
if (committed === null || !sameText(withoutRestampHeader(readText(repoRoot, entry.file)), withoutRestampHeader(committed)))
|
|
122
|
+
return;
|
|
123
|
+
accepted.push({ source: names[0], destination: entry.name });
|
|
124
|
+
});
|
|
125
|
+
return accepted;
|
|
126
|
+
}
|
|
127
127
|
async function baseMigrationEntryFindings(entry, repoRoot, git, baseSha, onBase) {
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
}
|
|
136
|
-
|
|
128
|
+
if (!entry.match)
|
|
129
|
+
return [];
|
|
130
|
+
if (onBase.has(entry.name)) {
|
|
131
|
+
const committed = await baseFileText(git, repoRoot, baseSha.sha, entry.file);
|
|
132
|
+
const current = readText(repoRoot, entry.file);
|
|
133
|
+
if (!sameText(current, committed))
|
|
134
|
+
return [found(DB_MIGRATION_SHAPE, entry.file, `${entry.file} differs from its content on ${baseSha.ref}; a migration on the base branch is immutable - write a new migration`, { base: baseSha.ref })];
|
|
135
|
+
}
|
|
136
|
+
return [];
|
|
137
|
+
}
|
|
137
138
|
function removedMigrationFindings(local, retired, baseNames, baseSha) {
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
139
|
+
const findings = [];
|
|
140
|
+
for (const name of baseNames) {
|
|
141
|
+
if (!local.some((entry) => entry.name === name) && !retired.has(name))
|
|
142
|
+
findings.push(found(DB_MIGRATION_SHAPE, `${MIGRATIONS_DIR}/${name}`, `${MIGRATIONS_DIR}/${name} exists on ${baseSha.ref} but is gone here; a migration on the base branch is immutable - restore it`, { base: baseSha.ref }));
|
|
143
|
+
}
|
|
144
|
+
return findings;
|
|
143
145
|
}
|
|
144
|
-
|
|
145
146
|
/**
|
|
146
147
|
* L02 findings for names, stamps, ordering and immutability of db/migrations/*.sql. `archived` are the files of
|
|
147
148
|
* db/migrations/archive/ (app.db.migrations.archive): never judged, and a migration moved there at a baseline
|
|
@@ -149,341 +150,380 @@ function removedMigrationFindings(local, retired, baseNames, baseSha) {
|
|
|
149
150
|
* on archived migrations, remote branches and the wall clock do not constrain a replacement baseline.
|
|
150
151
|
*/
|
|
151
152
|
export async function migrationShapeFindings({ repoRoot, migrations, archived = [], git, base }) {
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
153
|
+
const prefix = `${MIGRATIONS_DIR}/`;
|
|
154
|
+
const local = migrations.map((file) => {
|
|
155
|
+
const name = file.startsWith(prefix) ? file.slice(prefix.length) : file;
|
|
156
|
+
return { file, name, match: MIGRATION_NAME.exec(name) };
|
|
157
|
+
});
|
|
158
|
+
const findings = localMigrationFindings(local);
|
|
159
|
+
const retired = new Set(archived.map((file) => file.slice(MIGRATIONS_ARCHIVE_DIR.length + 1)));
|
|
160
|
+
const headFiles = await migrationFilesAt(git, repoRoot, 'HEAD');
|
|
161
|
+
const baseSha = await baseShaOf(git, repoRoot, base);
|
|
162
|
+
const baseFiles = baseSha ? await migrationFilesAt(git, repoRoot, baseSha.sha) : [];
|
|
163
|
+
const restamps = await verifiedRestamps(local, baseSha ? baseFiles : headFiles, repoRoot, git, baseSha?.sha ?? 'HEAD');
|
|
164
|
+
for (const restamp of restamps)
|
|
165
|
+
retired.add(restamp.source);
|
|
166
|
+
const history = migrationHistory(headFiles, retired, new Set(local.map((entry) => entry.name)));
|
|
167
|
+
findings.push(...migrationOrderingFindings(local, history, new Set(restamps.map((entry) => entry.destination))));
|
|
168
|
+
if (!baseSha)
|
|
169
|
+
return findings;
|
|
170
|
+
const baseNames = baseFiles.filter(isActiveMigration).map((file) => file.slice(prefix.length));
|
|
171
|
+
const onBase = new Set(baseNames);
|
|
172
|
+
await eachInOrder(local, async (entry) => {
|
|
173
|
+
findings.push(...await baseMigrationEntryFindings(entry, repoRoot, git, baseSha, onBase));
|
|
174
|
+
});
|
|
175
|
+
findings.push(...removedMigrationFindings(local, retired, baseNames, baseSha));
|
|
176
|
+
return findings;
|
|
177
|
+
}
|
|
176
178
|
const sqlName = (token) => token && ['word', 'ident'].includes(token.t) ? token.v : null;
|
|
177
179
|
const sqlWord = (token, value) => token?.t === 'word' && token.v === value;
|
|
178
|
-
|
|
179
180
|
function commentEnd(text, start) {
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
181
|
+
if (text.startsWith('--', start)) {
|
|
182
|
+
const end = text.indexOf('\n', start + 2);
|
|
183
|
+
return end === -1 ? text.length : end;
|
|
184
|
+
}
|
|
185
|
+
if (!text.startsWith('/*', start))
|
|
186
|
+
return null;
|
|
187
|
+
let depth = 1;
|
|
188
|
+
let index = start + 2;
|
|
189
|
+
while (index < text.length && depth > 0) {
|
|
190
|
+
if (text.startsWith('/*', index)) {
|
|
191
|
+
depth += 1;
|
|
192
|
+
index += 2;
|
|
193
|
+
}
|
|
194
|
+
else if (text.startsWith('*/', index)) {
|
|
195
|
+
depth -= 1;
|
|
196
|
+
index += 2;
|
|
197
|
+
}
|
|
198
|
+
else
|
|
199
|
+
index += 1;
|
|
200
|
+
}
|
|
201
|
+
return index;
|
|
202
|
+
}
|
|
195
203
|
function quotedToken(text, start, quote, escaped = false) {
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
204
|
+
let index = start + 1;
|
|
205
|
+
let value = '';
|
|
206
|
+
while (index < text.length) {
|
|
207
|
+
if (text[index] === quote && text[index + 1] === quote) {
|
|
208
|
+
value += quote;
|
|
209
|
+
index += 2;
|
|
210
|
+
}
|
|
211
|
+
else if (text[index] === quote)
|
|
212
|
+
return { value, end: index + 1 };
|
|
213
|
+
else if (escaped && text[index] === '\\') {
|
|
214
|
+
value += text[index + 1] ?? '';
|
|
215
|
+
index += 2;
|
|
216
|
+
}
|
|
217
|
+
else {
|
|
218
|
+
value += text[index];
|
|
219
|
+
index += 1;
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
return { value, end: index };
|
|
223
|
+
}
|
|
207
224
|
function sqlTokenAt(text, index) {
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
}
|
|
228
|
-
|
|
225
|
+
const char = text[index];
|
|
226
|
+
if (char === "'" || char === '"') {
|
|
227
|
+
const token = quotedToken(text, index, char);
|
|
228
|
+
return { t: char === '"' ? 'ident' : 'string', v: token.value, end: token.end };
|
|
229
|
+
}
|
|
230
|
+
if (/[eE]/.test(char) && text[index + 1] === "'") {
|
|
231
|
+
const token = quotedToken(text, index + 1, "'", true);
|
|
232
|
+
return { t: 'string', v: token.value, end: token.end };
|
|
233
|
+
}
|
|
234
|
+
const tag = char === '$' ? /^\$(?:[A-Za-z_]\w*)?\$/.exec(text.slice(index))?.[0] : null;
|
|
235
|
+
if (tag) {
|
|
236
|
+
const end = text.indexOf(tag, index + tag.length);
|
|
237
|
+
return { t: 'body', v: text.slice(index + tag.length, end === -1 ? text.length : end), end: end === -1 ? text.length : end + tag.length };
|
|
238
|
+
}
|
|
239
|
+
const word = /^[A-Za-z_][A-Za-z0-9_$]*/.exec(text.slice(index))?.[0];
|
|
240
|
+
if (word)
|
|
241
|
+
return { t: 'word', v: word.toLowerCase(), end: index + word.length };
|
|
242
|
+
const number = /^\d+(?:\.\d+)?/.exec(text.slice(index))?.[0];
|
|
243
|
+
if (number)
|
|
244
|
+
return { t: 'number', v: number, end: index + number.length };
|
|
245
|
+
return { t: 'punct', v: char, end: index + 1 };
|
|
246
|
+
}
|
|
229
247
|
/** Synchronous SQL tokens; literal values stay internal and must never be copied to a finding. */
|
|
230
248
|
export function databaseSqlTokens(text) {
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
249
|
+
const tokens = [];
|
|
250
|
+
let index = 0;
|
|
251
|
+
let line = 1;
|
|
252
|
+
while (index < text.length) {
|
|
253
|
+
if (/\s/.test(text[index])) {
|
|
254
|
+
if (text[index] === '\n')
|
|
255
|
+
line += 1;
|
|
256
|
+
index += 1;
|
|
257
|
+
continue;
|
|
258
|
+
}
|
|
259
|
+
const end = commentEnd(text, index);
|
|
260
|
+
if (end !== null) {
|
|
261
|
+
line += text.slice(index, end).split('\n').length - 1;
|
|
262
|
+
index = end;
|
|
263
|
+
continue;
|
|
264
|
+
}
|
|
265
|
+
const token = sqlTokenAt(text, index);
|
|
266
|
+
tokens.push({ t: token.t, v: token.v, line, index });
|
|
267
|
+
line += text.slice(index, token.end).split('\n').length - 1;
|
|
268
|
+
index = token.end;
|
|
239
269
|
}
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
const token = sqlTokenAt(text, index);
|
|
243
|
-
tokens.push({ t: token.t, v: token.v, line, index });
|
|
244
|
-
line += text.slice(index, token.end).split('\n').length - 1;
|
|
245
|
-
index = token.end;
|
|
246
|
-
}
|
|
247
|
-
return tokens;
|
|
248
|
-
}
|
|
249
|
-
|
|
270
|
+
return tokens;
|
|
271
|
+
}
|
|
250
272
|
/** Split executable SQL, retaining function bodies as opaque tokens until their language is known. */
|
|
251
273
|
export function databaseSqlStatements(tokens) {
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
274
|
+
const statements = [];
|
|
275
|
+
let current = [];
|
|
276
|
+
for (const token of tokens) {
|
|
277
|
+
if (token.t === 'punct' && token.v === ';') {
|
|
278
|
+
if (current.length)
|
|
279
|
+
statements.push(current);
|
|
280
|
+
current = [];
|
|
281
|
+
}
|
|
282
|
+
else
|
|
283
|
+
current.push(token);
|
|
258
284
|
}
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
return statements;
|
|
285
|
+
if (current.length)
|
|
286
|
+
statements.push(current);
|
|
287
|
+
return statements;
|
|
263
288
|
}
|
|
264
|
-
|
|
265
289
|
function executableStatementTokens(statement, depth) {
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
290
|
+
const isDo = sqlWord(statement[0], 'do');
|
|
291
|
+
const functionAt = statement.findIndex((token) => sqlWord(token, 'function') || sqlWord(token, 'procedure'));
|
|
292
|
+
const isFunction = sqlWord(statement[0], 'create') && functionAt > 0 && functionAt < 4;
|
|
293
|
+
if (!isDo && !isFunction)
|
|
294
|
+
return statement;
|
|
295
|
+
const languageAt = statement.findIndex((token) => sqlWord(token, 'language'));
|
|
296
|
+
const language = statement[languageAt + 1]?.v ?? 'sql';
|
|
297
|
+
if (languageAt !== -1 && !['sql', 'plpgsql'].includes(language))
|
|
298
|
+
return statement;
|
|
299
|
+
return statement.flatMap((token, index) => {
|
|
300
|
+
const body = token.t === 'body' || (token.t === 'string' && (isDo || sqlWord(statement[index - 1], 'as')));
|
|
301
|
+
if (!body)
|
|
302
|
+
return [token];
|
|
303
|
+
return databaseExecutableTokens(token.v, depth + 1).map((child) => ({ ...child, line: child.line + token.line - 1 }));
|
|
304
|
+
});
|
|
305
|
+
}
|
|
280
306
|
/** SQL and PL/pgSQL bodies are scanned; comments, data literals and other function languages are opaque. */
|
|
281
307
|
export function databaseExecutableTokens(text, depth = 0) {
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
308
|
+
const tokens = databaseSqlTokens(text);
|
|
309
|
+
if (depth > 8)
|
|
310
|
+
return tokens;
|
|
311
|
+
return databaseSqlStatements(tokens).flatMap((statement) => [...executableStatementTokens(statement, depth), { t: 'punct', v: ';' }]);
|
|
285
312
|
}
|
|
286
|
-
|
|
287
313
|
function nameAt(tokens, index) {
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
314
|
+
const first = sqlName(tokens[index]);
|
|
315
|
+
if (first === null)
|
|
316
|
+
return null;
|
|
317
|
+
const parts = [first];
|
|
318
|
+
let next = index + 1;
|
|
319
|
+
while (tokens[next]?.v === '.' && sqlName(tokens[next + 1]) !== null) {
|
|
320
|
+
parts.push(sqlName(tokens[next + 1]));
|
|
321
|
+
next += 2;
|
|
322
|
+
}
|
|
323
|
+
return { name: parts.join('.'), leaf: parts.at(-1), next };
|
|
324
|
+
}
|
|
296
325
|
const skipWords = (tokens, index, words) => {
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
326
|
+
let next = index;
|
|
327
|
+
while (words.some((word) => sqlWord(tokens[next], word)))
|
|
328
|
+
next += 1;
|
|
329
|
+
return next;
|
|
300
330
|
};
|
|
301
|
-
|
|
302
331
|
function dropObjects(tokens, start) {
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
332
|
+
const kind = tokens[start + 1]?.v;
|
|
333
|
+
if (!['table', 'role', 'user', 'schema', 'type', 'view', 'materialized', 'sequence', 'function', 'procedure', 'index', 'policy', 'trigger'].includes(kind))
|
|
334
|
+
return [];
|
|
335
|
+
let index = skipWords(tokens, start + 2, ['view', 'if', 'exists', 'concurrently']);
|
|
336
|
+
const objects = [];
|
|
337
|
+
while (index < tokens.length) {
|
|
338
|
+
const object = nameAt(tokens, index);
|
|
339
|
+
if (!object)
|
|
340
|
+
break;
|
|
341
|
+
objects.push({ ...object, kind, line: tokens[start].line });
|
|
342
|
+
if (tokens[object.next]?.v !== ',')
|
|
343
|
+
break;
|
|
344
|
+
index = object.next + 1;
|
|
345
|
+
}
|
|
346
|
+
return objects;
|
|
347
|
+
}
|
|
317
348
|
function columnAlterObject(tokens, index, table, line) {
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
349
|
+
let next = index + 1;
|
|
350
|
+
if (sqlWord(tokens[next], 'column'))
|
|
351
|
+
next += 1;
|
|
352
|
+
const column = nameAt(tokens, next);
|
|
353
|
+
if (!column)
|
|
354
|
+
return null;
|
|
355
|
+
const tail = tokens.slice(column.next);
|
|
356
|
+
const type = sqlWord(tail[0], 'type') || (sqlWord(tail[0], 'set') && sqlWord(tail[1], 'data') && sqlWord(tail[2], 'type'));
|
|
357
|
+
const notNull = sqlWord(tail[0], 'set') && sqlWord(tail[1], 'not') && sqlWord(tail[2], 'null');
|
|
358
|
+
const defaultSet = tokens.some((token, at) => sqlWord(token, 'alter') && sqlName(tokens[at + 1 + Number(sqlWord(tokens[at + 1], 'column'))]) === column.leaf
|
|
359
|
+
&& sqlWord(tokens[at + 2 + Number(sqlWord(tokens[at + 1], 'column'))], 'set') && sqlWord(tokens[at + 3 + Number(sqlWord(tokens[at + 1], 'column'))], 'default'));
|
|
360
|
+
if (!type && !(notNull && !defaultSet))
|
|
361
|
+
return null;
|
|
362
|
+
return { name: `${table.name}.${column.name}`, leaf: column.leaf, table: table.leaf, kind: 'column', line };
|
|
363
|
+
}
|
|
331
364
|
function alteredColumn(table, column, line) {
|
|
332
|
-
|
|
365
|
+
return { name: `${table.name}.${column.name}`, leaf: column.leaf, table: table.leaf, kind: 'column', line };
|
|
333
366
|
}
|
|
334
|
-
|
|
335
367
|
function tableActionObject(body, index, table, line) {
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
368
|
+
if (sqlWord(body[index], 'drop')) {
|
|
369
|
+
const constraint = sqlWord(body[index + 1], 'constraint');
|
|
370
|
+
const at = skipWords(body, index + 1, ['column', 'constraint', 'if', 'exists']);
|
|
371
|
+
if (sqlWord(body[at], 'default') || sqlWord(body[at], 'not'))
|
|
372
|
+
return null;
|
|
373
|
+
const column = nameAt(body, at);
|
|
374
|
+
return column ? { ...alteredColumn(table, column, line), kind: constraint ? 'constraint' : 'column' } : null;
|
|
375
|
+
}
|
|
376
|
+
if (sqlWord(body[index], 'rename')) {
|
|
377
|
+
const column = sqlWord(body[index + 1], 'column') ? nameAt(body, index + 2) : null;
|
|
378
|
+
return column ? alteredColumn(table, column, line) : { ...table, kind: 'table', line };
|
|
379
|
+
}
|
|
380
|
+
return sqlWord(body[index], 'alter') ? columnAlterObject(body, index, table, line) : null;
|
|
381
|
+
}
|
|
350
382
|
function alterObjects(tokens, start) {
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
383
|
+
const table = nameAt(tokens, skipWords(tokens, start + 2, ['if', 'exists', 'only']));
|
|
384
|
+
if (!table)
|
|
385
|
+
return [];
|
|
386
|
+
const body = tokens.slice(table.next);
|
|
387
|
+
return body.map((_token, index) => tableActionObject(body, index, table, tokens[start].line)).filter(Boolean);
|
|
355
388
|
}
|
|
356
|
-
|
|
357
389
|
function truncatedObjects(tokens, start) {
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
}
|
|
369
|
-
|
|
390
|
+
const objects = [];
|
|
391
|
+
let index = skipWords(tokens, start + 1, ['table', 'only']);
|
|
392
|
+
while (index < tokens.length) {
|
|
393
|
+
const table = nameAt(tokens, index);
|
|
394
|
+
if (!table)
|
|
395
|
+
break;
|
|
396
|
+
objects.push({ ...table, kind: 'table', line: tokens[start].line });
|
|
397
|
+
if (tokens[table.next]?.v !== ',')
|
|
398
|
+
break;
|
|
399
|
+
index = skipWords(tokens, table.next + 1, ['only']);
|
|
400
|
+
}
|
|
401
|
+
return objects;
|
|
402
|
+
}
|
|
370
403
|
function destructiveObjects(statement) {
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
404
|
+
const objects = [];
|
|
405
|
+
for (let index = 0; index < statement.length; index += 1) {
|
|
406
|
+
if (sqlWord(statement[index], 'drop'))
|
|
407
|
+
objects.push(...dropObjects(statement, index));
|
|
408
|
+
else if (sqlWord(statement[index], 'truncate'))
|
|
409
|
+
objects.push(...truncatedObjects(statement, index));
|
|
410
|
+
else if (sqlWord(statement[index], 'alter') && sqlWord(statement[index + 1], 'table'))
|
|
411
|
+
objects.push(...alterObjects(statement, index));
|
|
412
|
+
else if (sqlWord(statement[index], 'alter') && ['type', 'schema', 'view', 'sequence', 'function', 'procedure', 'index'].includes(statement[index + 1]?.v)) {
|
|
413
|
+
const object = nameAt(statement, index + 2);
|
|
414
|
+
if (object && statement.slice(object.next).some((token) => sqlWord(token, 'rename')))
|
|
415
|
+
objects.push({ ...object, kind: statement[index + 1].v, line: statement[index].line });
|
|
416
|
+
}
|
|
379
417
|
}
|
|
380
|
-
|
|
381
|
-
return objects;
|
|
418
|
+
return objects;
|
|
382
419
|
}
|
|
383
|
-
|
|
384
420
|
/** Keep the static parts of one SQL expression together across interpolation and string concatenation. */
|
|
385
421
|
function sourceSqlText(ts, expression, checker, visiting = new Set()) {
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
if (
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
}
|
|
402
|
-
|
|
422
|
+
const node = unwrapExpression(ts, expression);
|
|
423
|
+
if (ts.isStringLiteralLike(node))
|
|
424
|
+
return node.text;
|
|
425
|
+
if (ts.isTaggedTemplateExpression(node))
|
|
426
|
+
return sourceSqlText(ts, node.template, checker, visiting);
|
|
427
|
+
if (ts.isIdentifier(node)) {
|
|
428
|
+
const declaration = checker.getSymbolAtLocation(node)?.valueDeclaration;
|
|
429
|
+
if (!declaration || !ts.isVariableDeclaration(declaration) || !isConstVariable(ts, declaration)
|
|
430
|
+
|| !declaration.initializer || visiting.has(declaration))
|
|
431
|
+
return null;
|
|
432
|
+
return sourceSqlText(ts, declaration.initializer, checker, new Set([...visiting, declaration]));
|
|
433
|
+
}
|
|
434
|
+
if (ts.isTemplateExpression(node))
|
|
435
|
+
return node.head.text + node.templateSpans.map((span) => `${sourceSqlText(ts, span.expression, checker, visiting) ?? ' '}${span.literal.text}`).join('');
|
|
436
|
+
if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
|
|
437
|
+
return `${sourceSqlText(ts, node.left, checker, visiting) ?? ' '}${sourceSqlText(ts, node.right, checker, visiting) ?? ' '}`;
|
|
438
|
+
}
|
|
439
|
+
return null;
|
|
440
|
+
}
|
|
403
441
|
/** SET CONSTRAINTS names have no table qualifier; every matching table's constraint is affected. */
|
|
404
442
|
function globalConstraintNames(statement) {
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
443
|
+
const names = new Set();
|
|
444
|
+
for (let index = 0; index < statement.length; index += 1) {
|
|
445
|
+
if (!sqlWord(statement[index], 'set') || !sqlWord(statement[index + 1], 'constraints'))
|
|
446
|
+
continue;
|
|
447
|
+
let at = index + 2;
|
|
448
|
+
while (at < statement.length && !sqlWord(statement[at], 'all')) {
|
|
449
|
+
const constraint = nameAt(statement, at);
|
|
450
|
+
if (!constraint)
|
|
451
|
+
break;
|
|
452
|
+
names.add(constraint.leaf);
|
|
453
|
+
if (statement[constraint.next]?.v !== ',')
|
|
454
|
+
break;
|
|
455
|
+
at = constraint.next + 1;
|
|
456
|
+
}
|
|
415
457
|
}
|
|
416
|
-
|
|
417
|
-
return names;
|
|
458
|
+
return names;
|
|
418
459
|
}
|
|
419
|
-
|
|
420
460
|
function sourceNameScopes(ts, text, file) {
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
const
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
}
|
|
445
|
-
|
|
461
|
+
const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true);
|
|
462
|
+
const checker = lexicalChecker(ts, source);
|
|
463
|
+
const scopes = [];
|
|
464
|
+
const entityNames = /\.entity\.[cm]?tsx?$/.test(file) ? new Set() : null;
|
|
465
|
+
const addSql = (sql) => {
|
|
466
|
+
for (const statement of databaseSqlStatements(databaseSqlTokens(sql))) {
|
|
467
|
+
const names = new Set(statement.filter((token) => sqlName(token) !== null).map((token) => token.v));
|
|
468
|
+
if (entityNames)
|
|
469
|
+
for (const name of names)
|
|
470
|
+
entityNames.add(name);
|
|
471
|
+
else {
|
|
472
|
+
const constraints = new Set(statement.flatMap((token, index) => sqlWord(token, 'constraint') && sqlName(statement[index + 1]) !== null ? [statement[index + 1].v] : []));
|
|
473
|
+
scopes.push({ names, constraints, globalConstraints: globalConstraintNames(statement) });
|
|
474
|
+
}
|
|
475
|
+
}
|
|
476
|
+
};
|
|
477
|
+
const visit = (node) => {
|
|
478
|
+
const sql = sourceSqlText(ts, node, checker);
|
|
479
|
+
if (sql !== null)
|
|
480
|
+
addSql(sql);
|
|
481
|
+
if (entityNames && ts.isIdentifier(node))
|
|
482
|
+
entityNames.add(node.text);
|
|
483
|
+
ts.forEachChild(node, visit);
|
|
484
|
+
};
|
|
485
|
+
visit(source);
|
|
486
|
+
return entityNames ? [{ names: entityNames, constraints: entityNames, globalConstraints: new Set() }] : scopes;
|
|
487
|
+
}
|
|
446
488
|
/**
|
|
447
489
|
* Whether a be/src source references a destroyed object. A column (`<schema>.<table>.<column>`) is referenced only by a source that
|
|
448
490
|
* names both its table and the column in one SQL statement or entity, so separate queries cannot supply each other's names.
|
|
449
491
|
* SQL constraints require explicit constraint names, while entities retain their table/decorator association.
|
|
450
492
|
* Other object kinds match their leaf name conservatively.
|
|
451
493
|
*/
|
|
452
|
-
const referencesObject = (scopes, object) => scopes.some(({ names, constraints, globalConstraints }) =>
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
&& (!['column', 'constraint'].includes(object.kind) || !object.table || names.has(object.table))));
|
|
456
|
-
|
|
494
|
+
const referencesObject = (scopes, object) => scopes.some(({ names, constraints, globalConstraints }) => (object.kind === 'constraint' && globalConstraints.has(object.leaf))
|
|
495
|
+
|| ((object.kind === 'constraint' ? constraints : names).has(object.leaf)
|
|
496
|
+
&& (!['column', 'constraint'].includes(object.kind) || !object.table || names.has(object.table))));
|
|
457
497
|
function destructiveObjectFinding(file, object, contract, references) {
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
{ line: object.line, object: object.name, ...(reference ? { reference: reference.file } : {}) });
|
|
464
|
-
}
|
|
465
|
-
|
|
498
|
+
const reference = references.find(({ scopes }) => referencesObject(scopes, object));
|
|
499
|
+
if (contract && !reference)
|
|
500
|
+
return null;
|
|
501
|
+
const reason = reference && contract ? `${reference.file} still references this object; remove the reference before the contract migration`
|
|
502
|
+
: 'use a *_contract_* migration after the application stops using this object';
|
|
503
|
+
return found(DB_MIGRATION_DESTRUCTIVE, file, `${file}:${object.line} destructively changes ${object.name}; ${reason}`, { line: object.line, object: object.name, ...(reference ? { reference: reference.file } : {}) });
|
|
504
|
+
}
|
|
466
505
|
function destructiveFileFindings(file, text, references) {
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
}
|
|
478
|
-
|
|
506
|
+
const contract = /_contract_[a-z0-9]+(?:[-_][a-z0-9]+)*\.sql$/.test(file);
|
|
507
|
+
const seen = new Set();
|
|
508
|
+
const objects = databaseSqlStatements(databaseExecutableTokens(text)).flatMap(destructiveObjects);
|
|
509
|
+
return objects.flatMap((object) => {
|
|
510
|
+
const key = `${object.line}:${object.kind}:${object.name}`;
|
|
511
|
+
if (seen.has(key))
|
|
512
|
+
return [];
|
|
513
|
+
seen.add(key);
|
|
514
|
+
const finding = destructiveObjectFinding(file, object, contract, references);
|
|
515
|
+
return finding ? [finding] : [];
|
|
516
|
+
});
|
|
517
|
+
}
|
|
479
518
|
/** Destructive changes require a contract migration and no remaining SQL/entity reference in be/src. */
|
|
480
519
|
export function destructiveMigrationFindings({ repoRoot, migrations, files }) {
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
520
|
+
const sources = files.filter((file) => /^be\/src\/.+\.(?:sql|entity)\.[cm]?tsx?$/.test(file));
|
|
521
|
+
const ts = sources.length ? loadTypescript(repoRoot, HERE) : null;
|
|
522
|
+
if (sources.length && !ts)
|
|
523
|
+
return [found(DB_MIGRATION_DESTRUCTIVE, 'hfs.json', 'destructive migration checks require the TypeScript parser to read be/src references')];
|
|
524
|
+
const references = ts ? sources.map((file) => ({ file, scopes: sourceNameScopes(ts, readText(repoRoot, file) ?? '', file) })) : [];
|
|
525
|
+
return migrations.flatMap((file) => {
|
|
526
|
+
const text = readText(repoRoot, file);
|
|
527
|
+
return text === null ? [] : destructiveFileFindings(file, text, references);
|
|
528
|
+
});
|
|
489
529
|
}
|