mirror of
https://github.com/whyour/qinglong.git
synced 2026-09-20 16:07:11 +08:00
1027 lines
35 KiB
JavaScript
1027 lines
35 KiB
JavaScript
const assert = require('node:assert/strict');
|
|
const test = require('node:test');
|
|
const { DatabaseSync } = require('node:sqlite');
|
|
|
|
const {
|
|
LOCAL_PLUGIN_PACKAGE_PROMPT_ADMISSION_MIGRATION_ID,
|
|
LOCAL_PLUGIN_PACKAGE_PROMPT_FINALIZATION_MIGRATION_ID,
|
|
LOCAL_PLUGIN_PACKAGE_PROMPT_OUTPUT_ARTIFACT_MIGRATION_ID,
|
|
LOCAL_PLUGIN_PACKAGE_PROMPT_OUTPUT_KEY_RETIREMENT_MIGRATION_ID,
|
|
LOCAL_PLUGIN_PACKAGE_PROMPT_OUTPUT_TOMBSTONE_MIGRATION_ID,
|
|
LOCAL_MODEL_INVOCATION_MIGRATION_ID,
|
|
LOCAL_MODEL_INVOCATION_FEATURE_ACTIVATION_MIGRATION_ID,
|
|
LOCAL_MODEL_INVOCATION_MIGRATION_HISTORY_TABLE,
|
|
LOCAL_MODEL_INVOCATION_MIGRATION_PLAN_DIGEST,
|
|
LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
LOCAL_MODEL_PROVIDER_CREDENTIAL_CATALOG_MIGRATION_ID,
|
|
LOCAL_MODEL_INVOCATION_QUOTA_MIGRATION_ID,
|
|
LOCAL_MODEL_INVOCATION_PRICING_MIGRATION_ID,
|
|
LOCAL_MODEL_INVOCATION_USAGE_MIGRATION_ID,
|
|
LOCAL_MODEL_PRICE_CATALOG_AUTHORIZATION_MIGRATION_ID,
|
|
LOCAL_MODEL_PRICE_CATALOG_MIGRATION_ID,
|
|
POSTGRES_COPILOT_FAILURE_DIAGNOSIS_ADMISSION_MIGRATION_ID,
|
|
POSTGRES_MODEL_INVOCATION_MIGRATION_ID,
|
|
POSTGRES_MODEL_INVOCATION_MIGRATION_HISTORY_TABLE,
|
|
POSTGRES_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
POSTGRES_MODEL_INVOCATION_SCHEMA,
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_CATALOG_MIGRATION_ID,
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_MANAGEMENT_MIGRATION_ID,
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_MANAGEMENT_IDENTITY_MIGRATION_ID,
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_TEST_CONNECTION_MIGRATION_ID,
|
|
POSTGRES_MODEL_INVOCATION_QUOTA_MIGRATION_ID,
|
|
POSTGRES_MODEL_INVOCATION_PRICING_MIGRATION_ID,
|
|
POSTGRES_MODEL_INVOCATION_USAGE_MIGRATION_ID,
|
|
POSTGRES_MODEL_PRICE_CATALOG_AUTHORIZATION_MIGRATION_ID,
|
|
POSTGRES_MODEL_PRICE_CATALOG_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_ADMISSION_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_FINALIZATION_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_ARTIFACT_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_KEY_RETIREMENT_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_KEY_ROTATION_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_PRODUCT_AUTHORIZATION_MIGRATION_ID,
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_TOMBSTONE_MIGRATION_ID,
|
|
LocalModelInvocationFeatureNotReadyError,
|
|
assertLocalModelInvocationFeatureReady,
|
|
localModelInvocationMigrationDefinition,
|
|
migrateLocalModelInvocationFeature,
|
|
postgresModelInvocationMigrationDefinition,
|
|
} = require('@qinglong/ai/model-invocation-migration');
|
|
|
|
function createMainSqliteContract(client) {
|
|
client.exec(`
|
|
CREATE TABLE "QingLong3SchemaMigrations" (
|
|
migration_id TEXT PRIMARY KEY,
|
|
stream_id TEXT NOT NULL,
|
|
dialect TEXT NOT NULL,
|
|
checksum TEXT NOT NULL,
|
|
applied_at_ms INTEGER NOT NULL
|
|
);
|
|
CREATE TABLE "Runs" (id TEXT PRIMARY KEY);
|
|
CREATE TABLE "RunEvents" (id TEXT PRIMARY KEY);
|
|
CREATE TABLE "StepRuns" (
|
|
id TEXT PRIMARY KEY,
|
|
run_id TEXT NOT NULL,
|
|
UNIQUE (run_id, id)
|
|
);
|
|
CREATE TABLE "StepRunMutations" (mutation_id TEXT PRIMARY KEY);
|
|
`);
|
|
}
|
|
|
|
function localFeatureTables(client) {
|
|
return client
|
|
.prepare(
|
|
`SELECT name FROM sqlite_schema
|
|
WHERE type = 'table' AND
|
|
(name LIKE 'ModelInvocation%' OR name LIKE 'ModelPriceCatalog%')
|
|
ORDER BY name`,
|
|
)
|
|
.all()
|
|
.map((row) => row.name);
|
|
}
|
|
|
|
test('SQLite AI schema is an explicit independent feature migration', async () => {
|
|
const client = new DatabaseSync(':memory:');
|
|
client.exec('PRAGMA foreign_keys = ON');
|
|
createMainSqliteContract(client);
|
|
|
|
assert.deepEqual(localFeatureTables(client), []);
|
|
await migrateLocalModelInvocationFeature(client);
|
|
await migrateLocalModelInvocationFeature(client);
|
|
assert.deepEqual(localFeatureTables(client), [
|
|
'ModelInvocationCompletions',
|
|
'ModelInvocationFeatureHead',
|
|
'ModelInvocationFeatureTransitions',
|
|
'ModelInvocationPriceQuotes',
|
|
'ModelInvocationPriceSettlements',
|
|
'ModelInvocationPromptAdmissions',
|
|
'ModelInvocationPromptFinalizations',
|
|
'ModelInvocationPromptOutputArtifactTombstones',
|
|
'ModelInvocationPromptOutputArtifacts',
|
|
'ModelInvocationPromptOutputKeyRetirementCompletions',
|
|
'ModelInvocationPromptOutputKeyRetirementPreparations',
|
|
'ModelInvocationProviderCredentialAudits',
|
|
'ModelInvocationProviderCredentialBindings',
|
|
'ModelInvocationProviderCredentialTransitions',
|
|
'ModelInvocationQuotaReservations',
|
|
'ModelInvocationQuotaSettlements',
|
|
'ModelInvocationResolutions',
|
|
'ModelInvocationStarts',
|
|
'ModelInvocationUsageLedger',
|
|
'ModelPriceCatalogAuthorizations',
|
|
'ModelPriceCatalogHeads',
|
|
'ModelPriceCatalogPublications',
|
|
]);
|
|
const history = client
|
|
.prepare(
|
|
`SELECT migration_id, stream_id, checksum
|
|
FROM "${LOCAL_MODEL_INVOCATION_MIGRATION_HISTORY_TABLE}"
|
|
ORDER BY migration_id`,
|
|
)
|
|
.all();
|
|
assert.deepEqual(
|
|
history.map(({ migration_id, stream_id }) => ({
|
|
migration_id,
|
|
stream_id,
|
|
})),
|
|
[
|
|
{
|
|
migration_id: LOCAL_MODEL_INVOCATION_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_INVOCATION_USAGE_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_INVOCATION_QUOTA_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_INVOCATION_PRICING_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_PRICE_CATALOG_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_PRICE_CATALOG_AUTHORIZATION_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_INVOCATION_FEATURE_ACTIVATION_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_PLUGIN_PACKAGE_PROMPT_ADMISSION_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_PLUGIN_PACKAGE_PROMPT_FINALIZATION_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_PLUGIN_PACKAGE_PROMPT_OUTPUT_ARTIFACT_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_PLUGIN_PACKAGE_PROMPT_OUTPUT_TOMBSTONE_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id:
|
|
LOCAL_PLUGIN_PACKAGE_PROMPT_OUTPUT_KEY_RETIREMENT_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
{
|
|
migration_id: LOCAL_MODEL_PROVIDER_CREDENTIAL_CATALOG_MIGRATION_ID,
|
|
stream_id: LOCAL_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
},
|
|
],
|
|
);
|
|
assert.equal(
|
|
history[0].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[0].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[0].checksum,
|
|
'258e3fd9a250d53d7d0574c3c05b3f91c40c53b20a60b68a931babfc58a0451a',
|
|
);
|
|
assert.equal(
|
|
history[1].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[1].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[1].checksum,
|
|
'37e5c9bbf3f459ff036a032fc564dfd8cd78325234c9d7916bfff886b1018da5',
|
|
);
|
|
assert.equal(
|
|
history[2].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[2].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[2].checksum,
|
|
'fa734aac1a3f5affaf69f4fbe53a2c6ca628255ecdcde14c08b87b49d8162012',
|
|
);
|
|
assert.equal(
|
|
history[3].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[3].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[3].checksum,
|
|
'572e37d2f44df43a50b51a07c1b4b0bb87fbb22e9cafbd3421ec7ab250036951',
|
|
);
|
|
assert.equal(
|
|
history[4].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[4].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[4].checksum,
|
|
'20d5c288dfab65ac7ea75a96b7302f9d59cd1bfdf06af28f3868261f6e2e3013',
|
|
);
|
|
assert.equal(
|
|
history[5].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[5].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[5].checksum,
|
|
'3ee48d1468569c9dc1fa9f04031a48a220161762d48eeac4cd924e2dcd7abd21',
|
|
);
|
|
assert.equal(
|
|
history[6].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[6].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[6].checksum,
|
|
'2454987c61a48dc5286a883d755c709000e6fd630025373cb276723001bdcc6c',
|
|
);
|
|
assert.equal(
|
|
history[7].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[7].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[7].checksum,
|
|
'7f0b675231a79a5917dab1b7088ac8c393afef448e35309ca2e3a691af45bc79',
|
|
);
|
|
assert.equal(
|
|
history[8].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[8].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[8].checksum,
|
|
'bd4c6f9f72a16f7a0e8f6d7afc702c7fe1293e7fc6f60bc31f5604b30bbdd0b6',
|
|
);
|
|
assert.equal(
|
|
history[9].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[9].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[9].checksum,
|
|
'79bf3edcccf273046cb8b8ab60a7a0da881efd4e641009fa3c5833013cb7a75b',
|
|
);
|
|
assert.equal(
|
|
history[10].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[10].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[10].checksum,
|
|
'4283d738e3eeb99fce30d011fd7d090577aa897581ee83e691ae021eff3f369e',
|
|
);
|
|
assert.equal(
|
|
history[11].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[11].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[11].checksum,
|
|
'213d255cc40c536bbdc5fa41691839e0eb8e869db5a53ed93df50295ca8d5fc5',
|
|
);
|
|
assert.equal(
|
|
history[12].checksum,
|
|
localModelInvocationMigrationDefinition.migrations[12].checksum,
|
|
);
|
|
assert.equal(
|
|
localModelInvocationMigrationDefinition.migrations[12].checksum,
|
|
'ca9bcb4370d747884a34fdeae5079fdd7ccdaadd5ba9f66dba2faab09cfa3abb',
|
|
);
|
|
assert.equal(
|
|
LOCAL_MODEL_INVOCATION_MIGRATION_PLAN_DIGEST,
|
|
'2720c6e45f82adbb03641d1c19e8ff7e1875a763a0b53d4910a46ca308800aa0',
|
|
);
|
|
assert.deepEqual(
|
|
client
|
|
.prepare(
|
|
`SELECT migration_id FROM "QingLong3SchemaMigrations"
|
|
ORDER BY migration_id`,
|
|
)
|
|
.all(),
|
|
[],
|
|
);
|
|
assert.equal(
|
|
client.prepare('PRAGMA integrity_check').get().integrity_check,
|
|
'ok',
|
|
);
|
|
client.close();
|
|
});
|
|
|
|
test('SQLite AI feature readiness is read-only and rejects partial or drifted schema', async () => {
|
|
const client = new DatabaseSync(':memory:');
|
|
client.exec('PRAGMA foreign_keys = ON');
|
|
createMainSqliteContract(client);
|
|
|
|
assert.throws(
|
|
() => assertLocalModelInvocationFeatureReady(client),
|
|
LocalModelInvocationFeatureNotReadyError,
|
|
);
|
|
await migrateLocalModelInvocationFeature(client);
|
|
assert.doesNotThrow(() => assertLocalModelInvocationFeatureReady(client));
|
|
|
|
client
|
|
.prepare(
|
|
`UPDATE "${LOCAL_MODEL_INVOCATION_MIGRATION_HISTORY_TABLE}"
|
|
SET checksum = ?
|
|
WHERE migration_id = ?`,
|
|
)
|
|
.run('f'.repeat(64), LOCAL_MODEL_PRICE_CATALOG_AUTHORIZATION_MIGRATION_ID);
|
|
assert.throws(
|
|
() => assertLocalModelInvocationFeatureReady(client),
|
|
LocalModelInvocationFeatureNotReadyError,
|
|
);
|
|
assert.equal(
|
|
client
|
|
.prepare(
|
|
`SELECT count(*) AS count
|
|
FROM "${LOCAL_MODEL_INVOCATION_MIGRATION_HISTORY_TABLE}"`,
|
|
)
|
|
.get().count,
|
|
13,
|
|
);
|
|
client.close();
|
|
});
|
|
|
|
test('SQLite AI migration refuses to create a parallel baseline', async () => {
|
|
const client = new DatabaseSync(':memory:');
|
|
|
|
await assert.rejects(
|
|
migrateLocalModelInvocationFeature(client),
|
|
/requires the main SQLite migration stream/,
|
|
);
|
|
assert.deepEqual(localFeatureTables(client), []);
|
|
client.close();
|
|
});
|
|
|
|
test('PostgreSQL AI schema is an independent reviewed feature stream', async () => {
|
|
assert.equal(
|
|
POSTGRES_MODEL_INVOCATION_MIGRATION_STREAM_ID,
|
|
'ql3-ai-model-invocation-postgresql',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_INVOCATION_MIGRATION_ID,
|
|
'pg-9001-ai-model-invocations',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_INVOCATION_USAGE_MIGRATION_ID,
|
|
'pg-9002-ai-model-usage-ledger',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_INVOCATION_QUOTA_MIGRATION_ID,
|
|
'pg-9003-ai-model-usage-quota',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_INVOCATION_PRICING_MIGRATION_ID,
|
|
'pg-9004-ai-model-pricing-snapshots',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_PRICE_CATALOG_MIGRATION_ID,
|
|
'pg-9005-ai-model-price-catalog',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_PRICE_CATALOG_AUTHORIZATION_MIGRATION_ID,
|
|
'pg-9006-ai-model-price-catalog-authorizations',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_ADMISSION_MIGRATION_ID,
|
|
'pg-9007-ai-plugin-package-prompt-admissions',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_FINALIZATION_MIGRATION_ID,
|
|
'pg-9008-ai-plugin-package-prompt-finalizations',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_ARTIFACT_MIGRATION_ID,
|
|
'pg-9009-ai-plugin-package-prompt-output-artifacts',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_TOMBSTONE_MIGRATION_ID,
|
|
'pg-9010-ai-plugin-package-prompt-output-tombstones',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_KEY_RETIREMENT_MIGRATION_ID,
|
|
'pg-9011-ai-plugin-package-prompt-output-key-retirements',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_CATALOG_MIGRATION_ID,
|
|
'pg-9012-ai-model-provider-credential-catalog',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_MANAGEMENT_MIGRATION_ID,
|
|
'pg-9013-ai-model-provider-credential-management-boundary',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_MANAGEMENT_IDENTITY_MIGRATION_ID,
|
|
'pg-9014-ai-model-provider-credential-management-identity-ledger',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_PROVIDER_CREDENTIAL_TEST_CONNECTION_MIGRATION_ID,
|
|
'pg-9015-ai-model-provider-credential-test-connection',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_OUTPUT_KEY_ROTATION_MIGRATION_ID,
|
|
'pg-9016-ai-plugin-package-prompt-output-key-rotation',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_PLUGIN_PACKAGE_PROMPT_PRODUCT_AUTHORIZATION_MIGRATION_ID,
|
|
'pg-9017-ai-plugin-package-prompt-product-authorization',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_COPILOT_FAILURE_DIAGNOSIS_ADMISSION_MIGRATION_ID,
|
|
'pg-9018-ai-copilot-failure-diagnosis-admissions',
|
|
);
|
|
assert.equal(
|
|
POSTGRES_MODEL_INVOCATION_MIGRATION_HISTORY_TABLE,
|
|
'ai_schema_migrations',
|
|
);
|
|
assert.equal(POSTGRES_MODEL_INVOCATION_SCHEMA, 'ql3_ai');
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrationIdScheme,
|
|
'postgres-prefixed',
|
|
);
|
|
assert.match(
|
|
postgresModelInvocationMigrationDefinition.migrations[0].checksum,
|
|
/^[0-9a-f]{64}$/,
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[0].checksum,
|
|
'69f72286fba2988ba372f006eb894a7f8b89f4b1acd9da68dc1cdafc3ca96ea7',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[1].checksum,
|
|
'95ad6f46163b0bbc2583dddf492f91f767a00554683186f244d3f6a22a2ad00c',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[2].checksum,
|
|
'13ea1a904eb799bcae1b474d76b164a70748bdcca8e1e6ded9952921a291a855',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[3].checksum,
|
|
'd38b12c2640fdd9fe21dc43a4743fb3480c988fa0a87e210fd81074d87569d2f',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[4].checksum,
|
|
'7db1a80fab1aa3dee3a4c4bcae5add53758418504f63f4b7d253b090506d7864',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[5].checksum,
|
|
'486d46115e28e90604a47231fe95e3b1687649c063d93bf7ce267783f2a7165f',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[6].checksum,
|
|
'1ed94eae2225b26e89e8c5d34e265e143e8150ff1811f5d8ae1fda52a6603db0',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[7].checksum,
|
|
'8dfd02e8e4947acb03516795ae37ef7aae5ee52a25b1fe3cd1a8640782c5b235',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[8].checksum,
|
|
'cb4156b109694c2b3aaf60a870179da04e10b47dbddfc92db3a7c4a58dfd1c2d',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[9].checksum,
|
|
'8972237fa41c80d131c32b380f617e8c7720687980e9accfb08f8fb19b7d8b5f',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[10].checksum,
|
|
'843ea53460f6580801cb12428d35c5571fd36bbee64e7801d2c3f98ea39d8392',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[11].checksum,
|
|
'4c83f5dda3c922aefd77c58760881f926e63e33628120f2fe6c71a53b30a1248',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[12].checksum,
|
|
'c02a4c6b2953cc331580b6287283d33739c30c2e189d011f392c13ecea497224',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[13].checksum,
|
|
'02098fad764199bc5a7750483d050be5e5acdbcecd05c0975c3fe4e5be03c782',
|
|
);
|
|
assert.match(
|
|
postgresModelInvocationMigrationDefinition.migrations[14].checksum,
|
|
/^[0-9a-f]{64}$/,
|
|
);
|
|
assert.match(
|
|
postgresModelInvocationMigrationDefinition.migrations[16].checksum,
|
|
/^[0-9a-f]{64}$/,
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations[17].checksum,
|
|
'cd0837c68ecc6c2bce58d048308d0239397b6347b4483f02372f966c05ae7ad6',
|
|
);
|
|
assert.equal(
|
|
postgresModelInvocationMigrationDefinition.migrations.length,
|
|
18,
|
|
);
|
|
|
|
const diagnosisAdmissionStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[17].up({
|
|
async query(statement) {
|
|
diagnosisAdmissionStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const diagnosisAdmissionSql = diagnosisAdmissionStatements.join('\n');
|
|
assert.match(
|
|
diagnosisAdmissionSql,
|
|
/CREATE TABLE "ql3_ai"\."copilot_failure_diagnosis_admissions"/,
|
|
);
|
|
assert.match(
|
|
diagnosisAdmissionSql,
|
|
/CREATE FUNCTION[\s\S]*copilot_failure_diagnosis_admission_source_snapshot/,
|
|
);
|
|
assert.match(diagnosisAdmissionSql, /SECURITY DEFINER/);
|
|
assert.match(diagnosisAdmissionSql, /FOR SHARE OF project, binding/);
|
|
assert.match(
|
|
diagnosisAdmissionSql,
|
|
/FOR SHARE OF source_run, source_attempt/,
|
|
);
|
|
assert.match(diagnosisAdmissionSql, /TO ql3_runtime/);
|
|
assert.doesNotMatch(diagnosisAdmissionSql, /GRANT[^;]*(?:UPDATE|DELETE)/);
|
|
|
|
const retirementStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[10].up({
|
|
async query(statement) {
|
|
retirementStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const retirementSql = retirementStatements.join('\n');
|
|
assert.match(
|
|
retirementSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_output_key_retirement_preparations"/,
|
|
);
|
|
assert.match(
|
|
retirementSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_output_key_retirement_completions"/,
|
|
);
|
|
assert.match(retirementSql, /TO ql3_runtime/);
|
|
assert.match(retirementSql, /TO ql3_ai_maintenance/);
|
|
|
|
const credentialStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[11].up({
|
|
async query(statement) {
|
|
credentialStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const credentialSql = credentialStatements.join('\n');
|
|
assert.match(
|
|
credentialSql,
|
|
/CREATE TABLE "ql3_ai"\."model_provider_credential_bindings"/,
|
|
);
|
|
assert.match(
|
|
credentialSql,
|
|
/CREATE TABLE "ql3_ai"\."model_provider_credential_transitions"/,
|
|
);
|
|
assert.match(
|
|
credentialSql,
|
|
/CREATE TABLE "ql3_ai"\."model_provider_credential_audits"/,
|
|
);
|
|
assert.match(credentialSql, /TO ql3_runtime/);
|
|
assert.match(credentialSql, /TO ql3_ai_maintenance/);
|
|
|
|
const credentialManagementStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[12].up({
|
|
async query(statement) {
|
|
credentialManagementStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const credentialManagementSql = credentialManagementStatements.join('\n');
|
|
assert.match(
|
|
credentialManagementSql,
|
|
/GRANT CONNECT ON DATABASE %I TO ql3_ai_credential_manager/,
|
|
);
|
|
assert.match(
|
|
credentialManagementSql,
|
|
/GRANT SELECT ON TABLE[\s\S]*"ql3"\."projects"[\s\S]*"ql3"\."project_role_bindings"[\s\S]*"ql3"\."security_audit_events"[\s\S]*TO ql3_ai_credential_manager/,
|
|
);
|
|
assert.match(
|
|
credentialManagementSql,
|
|
/GRANT INSERT ON TABLE "ql3"\."security_audit_events"[\s\S]*TO ql3_ai_credential_manager/,
|
|
);
|
|
assert.match(
|
|
credentialManagementSql,
|
|
/GRANT INSERT ON TABLE[\s\S]*model_provider_credential_bindings[\s\S]*model_provider_credential_transitions[\s\S]*TO ql3_ai_credential_manager/,
|
|
);
|
|
assert.doesNotMatch(
|
|
credentialManagementSql,
|
|
/GRANT[^;]*(?:model_invocation_prompt_output|ql3_ai_maintenance)/,
|
|
);
|
|
assert.match(
|
|
credentialManagementSql,
|
|
/REVOKE ALL ON TABLE[\s\S]*model_provider_credential_bindings[\s\S]*model_provider_credential_transitions[\s\S]*model_provider_credential_audits[\s\S]*FROM ql3_ai_maintenance/,
|
|
);
|
|
|
|
const credentialIdentityStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[13].up({
|
|
async query(statement) {
|
|
credentialIdentityStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const credentialIdentitySql = credentialIdentityStatements.join('\n');
|
|
assert.match(
|
|
credentialIdentitySql,
|
|
/CREATE TABLE "ql3_ai"\."model_provider_credential_management_identity_keyset_ledger"/,
|
|
);
|
|
assert.match(
|
|
credentialIdentitySql,
|
|
/GRANT SELECT, INSERT, UPDATE[\s\S]*TO ql3_ai_credential_manager/,
|
|
);
|
|
assert.match(credentialIdentitySql, /FROM PUBLIC, ql3_ai_maintenance/);
|
|
assert.doesNotMatch(credentialIdentitySql, /GRANT[^;]*DELETE/);
|
|
|
|
const credentialTestStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[14].up({
|
|
async query(statement) {
|
|
credentialTestStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const credentialTestSql = credentialTestStatements.join('\n');
|
|
for (const table of [
|
|
'model_provider_credential_test_plans',
|
|
'model_provider_credential_test_quota_buckets',
|
|
'model_provider_credential_test_executions',
|
|
'model_provider_credential_test_results',
|
|
]) {
|
|
assert.match(
|
|
credentialTestSql,
|
|
new RegExp(`CREATE TABLE "ql3_ai"\\."${table}"`),
|
|
);
|
|
}
|
|
assert.match(
|
|
credentialTestSql,
|
|
/GRANT CONNECT ON DATABASE %I TO ql3_ai_credential_tester/,
|
|
);
|
|
assert.match(
|
|
credentialTestSql,
|
|
/GRANT SELECT, INSERT, UPDATE ON TABLE[\s\S]*model_provider_credential_test_quota_buckets[\s\S]*TO ql3_ai_credential_manager/,
|
|
);
|
|
assert.match(
|
|
credentialTestSql,
|
|
/GRANT INSERT ON TABLE[\s\S]*model_provider_credential_test_executions[\s\S]*model_provider_credential_test_results[\s\S]*TO ql3_ai_credential_tester/,
|
|
);
|
|
for (const statement of credentialTestStatements.filter((value) =>
|
|
value.includes('TO ql3_ai_credential_tester'),
|
|
)) {
|
|
assert.doesNotMatch(statement, /GRANT[\s\S]*(?:UPDATE|DELETE)/);
|
|
}
|
|
|
|
const rotationStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[15].up({
|
|
async query(statement) {
|
|
rotationStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const rotationSql = rotationStatements.join('\n');
|
|
assert.match(
|
|
rotationSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_output_key_rotation_preparations"/,
|
|
);
|
|
assert.match(
|
|
rotationSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_output_key_rotation_completions"/,
|
|
);
|
|
assert.match(
|
|
rotationSql,
|
|
/UNIQUE \(expected_secret_uid, expected_catalog_digest\)/,
|
|
);
|
|
assert.match(rotationSql, /TO ql3_ai_maintenance/);
|
|
assert.doesNotMatch(rotationSql, /GRANT[^;]*TO ql3_runtime/);
|
|
assert.doesNotMatch(rotationSql, /GRANT[^;]*(?:UPDATE|DELETE)/);
|
|
|
|
const productAuthorizationStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[16].up({
|
|
async query(statement) {
|
|
productAuthorizationStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const productAuthorizationSql = productAuthorizationStatements.join('\n');
|
|
assert.match(
|
|
productAuthorizationSql,
|
|
/CREATE FUNCTION[\s\S]*plugin_package_prompt_authorize_admission/,
|
|
);
|
|
assert.match(productAuthorizationSql, /SECURITY DEFINER/);
|
|
assert.match(productAuthorizationSql, /TO ql3_runtime/);
|
|
assert.doesNotMatch(productAuthorizationSql, /GRANT[^;]*TO ql3_admin/);
|
|
|
|
const statements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[0].up({
|
|
async query(statement) {
|
|
statements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const sql = statements.join('\n');
|
|
assert.match(sql, /CREATE TABLE "ql3_ai"\."model_invocation_starts"/);
|
|
assert.match(sql, /CREATE TABLE "ql3_ai"\."model_invocation_completions"/);
|
|
assert.match(sql, /CREATE TABLE "ql3_ai"\."model_invocation_resolutions"/);
|
|
assert.match(
|
|
sql,
|
|
/FOREIGN KEY \(mutation_id\)[\s\S]*"ql3"\."step_run_mutations"/,
|
|
);
|
|
assert.match(sql, /FOREIGN KEY \(run_event_id\)[\s\S]*"ql3"\."run_events"/);
|
|
assert.match(
|
|
sql,
|
|
/REVOKE ALL ON TABLE[\s\S]*model_invocation_starts[\s\S]*FROM PUBLIC/,
|
|
);
|
|
assert.match(
|
|
sql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_resolutions[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.doesNotMatch(sql, /model_invocation_(?:starts|completions)_step_uidx/);
|
|
assert.match(sql, /model_invocation_starts_step_history_idx/);
|
|
assert.match(sql, /model_invocation_completions_step_history_idx/);
|
|
assert.doesNotMatch(sql, /TO ql3_admin/);
|
|
assert.doesNotMatch(sql, /TO ql3_worker_ingress/);
|
|
|
|
const usageStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[1].up({
|
|
async query(statement) {
|
|
usageStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const usageSql = usageStatements.join('\n');
|
|
assert.match(
|
|
usageSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_usage_ledger"/,
|
|
);
|
|
assert.match(
|
|
usageSql,
|
|
/FOREIGN KEY \(invocation_id, completion_digest\)[\s\S]*model_invocation_completions/,
|
|
);
|
|
assert.match(
|
|
usageSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_usage_ledger[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.deepEqual(
|
|
usageStatements.filter((statement) => statement.startsWith('GRANT ')),
|
|
[
|
|
`GRANT SELECT, INSERT ON TABLE
|
|
"ql3_ai"."model_invocation_usage_ledger"
|
|
TO ql3_runtime`,
|
|
],
|
|
);
|
|
assert.doesNotMatch(usageSql, /TO ql3_admin|TO ql3_worker_ingress/);
|
|
|
|
const quotaStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[2].up({
|
|
async query(statement) {
|
|
quotaStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const quotaSql = quotaStatements.join('\n');
|
|
assert.match(
|
|
quotaSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_quota_reservations"/,
|
|
);
|
|
assert.match(
|
|
quotaSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_quota_settlements"/,
|
|
);
|
|
assert.match(
|
|
quotaSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_quota_reservations[\s\S]*model_invocation_quota_settlements[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.deepEqual(
|
|
quotaStatements.filter((statement) =>
|
|
/^(?:UPDATE|DELETE)\b/.test(statement),
|
|
),
|
|
[],
|
|
);
|
|
assert.doesNotMatch(quotaSql, /TO ql3_admin|TO ql3_worker_ingress/);
|
|
|
|
const pricingStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[3].up({
|
|
async query(statement) {
|
|
pricingStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const pricingSql = pricingStatements.join('\n');
|
|
assert.match(
|
|
pricingSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_price_quotes"/,
|
|
);
|
|
assert.match(
|
|
pricingSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_price_settlements"/,
|
|
);
|
|
assert.match(
|
|
pricingSql,
|
|
/FOREIGN KEY \(invocation_id, quote_digest\)[\s\S]*model_invocation_price_quotes/,
|
|
);
|
|
assert.match(
|
|
pricingSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_price_quotes[\s\S]*model_invocation_price_settlements[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.deepEqual(
|
|
pricingStatements.filter((statement) =>
|
|
/^(?:UPDATE|DELETE)\b/.test(statement),
|
|
),
|
|
[],
|
|
);
|
|
assert.doesNotMatch(pricingSql, /TO ql3_admin|TO ql3_worker_ingress/);
|
|
|
|
const catalogStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[4].up({
|
|
async query(statement) {
|
|
catalogStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const catalogSql = catalogStatements.join('\n');
|
|
assert.match(
|
|
catalogSql,
|
|
/CREATE TABLE "ql3_ai"\."model_price_catalog_publications"/,
|
|
);
|
|
assert.match(
|
|
catalogSql,
|
|
/CREATE TABLE "ql3_ai"\."model_price_catalog_heads"/,
|
|
);
|
|
assert.match(
|
|
catalogSql,
|
|
/GRANT SELECT ON TABLE[\s\S]*model_price_catalog_publications[\s\S]*model_price_catalog_heads[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.match(
|
|
catalogSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_price_catalog_publications[\s\S]*model_price_catalog_heads[\s\S]*TO ql3_admin/,
|
|
);
|
|
assert.doesNotMatch(
|
|
catalogSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.doesNotMatch(
|
|
catalogSql,
|
|
/TO ql3_package_manager|TO ql3_package_executor|TO ql3_worker_ingress/,
|
|
);
|
|
assert.deepEqual(
|
|
catalogStatements.filter((statement) =>
|
|
/^(?:UPDATE|DELETE)\b/.test(statement),
|
|
),
|
|
[],
|
|
);
|
|
|
|
const authorizationStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[5].up({
|
|
async query(statement) {
|
|
authorizationStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const authorizationSql = authorizationStatements.join('\n');
|
|
assert.match(
|
|
authorizationSql,
|
|
/CREATE TABLE "ql3_ai"\."model_price_catalog_authorizations"/,
|
|
);
|
|
assert.match(
|
|
authorizationSql,
|
|
/FOREIGN KEY \(publication_digest\)[\s\S]*model_price_catalog_publications/,
|
|
);
|
|
assert.match(
|
|
authorizationSql,
|
|
/FOREIGN KEY \(head_digest\)[\s\S]*model_price_catalog_heads/,
|
|
);
|
|
assert.match(
|
|
authorizationSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_price_catalog_authorizations[\s\S]*TO ql3_admin/,
|
|
);
|
|
assert.doesNotMatch(authorizationSql, /TO ql3_runtime/);
|
|
assert.deepEqual(
|
|
authorizationStatements.filter((statement) =>
|
|
/^(?:UPDATE|DELETE)\b/.test(statement),
|
|
),
|
|
[],
|
|
);
|
|
|
|
const promptAdmissionStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[6].up({
|
|
async query(statement) {
|
|
promptAdmissionStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const promptAdmissionSql = promptAdmissionStatements.join('\n');
|
|
assert.match(
|
|
promptAdmissionSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_admissions"/,
|
|
);
|
|
assert.match(
|
|
promptAdmissionSql,
|
|
/REFERENCES "ql3"\."plugin_package_automation_publications"/,
|
|
);
|
|
assert.match(
|
|
promptAdmissionSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_prompt_admissions[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.match(
|
|
promptAdmissionSql,
|
|
/CREATE FUNCTION[\s\S]*"ql3_ai"\."plugin_package_prompt_admission_snapshot"/,
|
|
);
|
|
assert.match(promptAdmissionSql, /plugin_package_automation_start_allowed/);
|
|
assert.match(
|
|
promptAdmissionSql,
|
|
/GRANT EXECUTE ON FUNCTION[\s\S]*plugin_package_prompt_admission_snapshot[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.doesNotMatch(
|
|
promptAdmissionSql,
|
|
/TO ql3_admin|TO ql3_package_manager|TO ql3_worker_ingress/,
|
|
);
|
|
|
|
const promptFinalizationStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[7].up({
|
|
async query(statement) {
|
|
promptFinalizationStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const promptFinalizationSql = promptFinalizationStatements.join('\n');
|
|
assert.match(
|
|
promptFinalizationSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_finalizations"/,
|
|
);
|
|
assert.match(
|
|
promptFinalizationSql,
|
|
/FOREIGN KEY \(event_id\)[\s\S]*REFERENCES "ql3"\."run_events"/,
|
|
);
|
|
assert.match(
|
|
promptFinalizationSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_prompt_finalizations[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.doesNotMatch(
|
|
`${promptAdmissionSql}\n${promptFinalizationSql}`,
|
|
/GRANT (?:UPDATE|DELETE)|TO ql3_admin|TO ql3_worker_ingress/,
|
|
);
|
|
|
|
const promptOutputArtifactStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[8].up({
|
|
async query(statement) {
|
|
promptOutputArtifactStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const promptOutputArtifactSql = promptOutputArtifactStatements.join('\n');
|
|
assert.match(
|
|
promptOutputArtifactSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_output_artifacts"/,
|
|
);
|
|
assert.match(
|
|
promptOutputArtifactSql,
|
|
/FOREIGN KEY \(invocation_id\)[\s\S]*model_invocation_prompt_admissions/,
|
|
);
|
|
assert.match(
|
|
promptOutputArtifactSql,
|
|
/FOREIGN KEY \(invocation_id\)[\s\S]*model_invocation_starts/,
|
|
);
|
|
assert.match(
|
|
promptOutputArtifactSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_prompt_output_artifacts[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.doesNotMatch(
|
|
promptOutputArtifactSql,
|
|
/GRANT (?:UPDATE|DELETE)|TO ql3_admin|TO ql3_package_manager|TO ql3_package_executor|TO ql3_worker_ingress/,
|
|
);
|
|
|
|
const promptOutputTombstoneStatements = [];
|
|
await postgresModelInvocationMigrationDefinition.migrations[9].up({
|
|
async query(statement) {
|
|
promptOutputTombstoneStatements.push(statement);
|
|
return { rows: [] };
|
|
},
|
|
});
|
|
const promptOutputTombstoneSql = promptOutputTombstoneStatements.join('\n');
|
|
assert.match(
|
|
promptOutputTombstoneSql,
|
|
/CREATE TABLE "ql3_ai"\."model_invocation_prompt_output_artifact_tombstones"/,
|
|
);
|
|
assert.match(
|
|
promptOutputTombstoneSql,
|
|
/GRANT CONNECT ON DATABASE %I TO ql3_ai_maintenance/,
|
|
);
|
|
assert.match(
|
|
promptOutputTombstoneSql,
|
|
/FOREIGN KEY \(invocation_id\)[\s\S]*model_invocation_prompt_admissions/,
|
|
);
|
|
assert.match(
|
|
promptOutputTombstoneSql,
|
|
/GRANT SELECT ON TABLE[\s\S]*model_invocation_prompt_output_artifact_tombstones[\s\S]*TO ql3_runtime/,
|
|
);
|
|
assert.match(
|
|
promptOutputTombstoneSql,
|
|
/GRANT SELECT, DELETE ON TABLE[\s\S]*model_invocation_prompt_output_artifacts[\s\S]*TO ql3_ai_maintenance/,
|
|
);
|
|
assert.match(
|
|
promptOutputTombstoneSql,
|
|
/GRANT SELECT, INSERT ON TABLE[\s\S]*model_invocation_prompt_output_artifact_tombstones[\s\S]*TO ql3_ai_maintenance/,
|
|
);
|
|
assert.doesNotMatch(
|
|
promptOutputTombstoneSql,
|
|
/GRANT (?:UPDATE|DELETE)[\s\S]*model_invocation_prompt_output_artifact_tombstones|TO ql3_admin|TO ql3_package_manager|TO ql3_package_executor|TO ql3_worker_ingress/,
|
|
);
|
|
});
|