Versjon 1.0.0-alpha.1nyeste
Kapittel 2.22
Kjøremiljøet for programtillegg
SDK-modulene (programvareutviklingssett) som programtillegget ditt kjører på, fra omfangsvakten og databasegjerdet til UNO-utsendelse, avlesning av KI-ruten (kunstig intelligens) og lisenskontroller. Deretter testing mot en ekte database, registrering av ferdighetene dine og klargjøring.
Denne siden er oversatt med KI fra den engelske originalen. Hvis noe er uklart, er den engelske siden referansen. Les denne siden på engelsk

Kjøretidshalvdelen av SDK-et (programvareutviklingssettet) er et sett med moduler under @adverant-nexus/plugin-sdk/runtime/*, pluss testhjelpere under testing/*. Du importerer dem; du implementerer dem ikke på nytt. Det er hele ideen, og det krevde én avvist gjennomgang før jeg tok det på alvor: anmelderens merknad til min første utvidelses håndskrevne omfangssjekk var en enkelt linje: «SDK-et har allerede dette, og din godtar et utfordringstoken for MFA (flerfaktorautentisering) som en økt».
Dette kapittelet følger en forespørsel gjennom en kjørende utvidelse, slik fullservicemalen kobler den opp: omfangsvakten, databasegjerdet, den ene tillatte kryssingen, utsendelse gjennom UNO, lesing av KI-ruten (kunstig intelligens) og lisenssjekkene. Deretter dekker det testing, registrering av manifestferdighetene dine og innføringstrinnene.
Omfang: én vakt per rammeverk
Hver /api-rute bærer omfangsvakten. Den verifiserer ihændehavertokenet (bearer token), løser de tre aksene (leietaker, eier, enhet) fra det, avviser en forespørselskropp som navngir en leietaker, anvender rutens rettighet fra manifestets register, og lar først da behandleren kjøre. SDK-et leverer én adapter per rammeverk, alle fra @adverant-nexus/plugin-sdk/runtime/scope og alle med de samme innstillingene.
| Rammeverk | Adapter |
|---|---|
| Express | scopeMiddleware |
| Fastify | requireScope, som en preHandler |
| Neste | withScope, som pakker inn behandleren; en Next-behandler blir ikke fortalt ruten sin, så withScope tar den som et tredje argument |
Her er malens Express-oppkobling, nedkortet. Verifikatoren tilhører SDK-et, og den holder tokenet til identitetstjenestens øktformat: kun HS256; iss, exp, iat og jti er påkrevd; en levetid på høyst én time; og ingen MFA-utfordring, personifisering eller ressurstoken for OAuth (den åpne standarden for delegert autorisasjon) godtas som en økt.
import { platformAccessTokenVerifier } from "@adverant-nexus/plugin-sdk/runtime/platform-token";
import { scopeMiddleware } from "@adverant-nexus/plugin-sdk/runtime/scope";
const requireScope = scopeMiddleware({
verify: platformAccessTokenVerifier(config.PLATFORM_JWT_SECRET),
rights: { manifest },
});
router.get("/api/projects", requireScope, async (req, res) => {
res.json({ projects: await db.listProjects(scopeOf(req)) });
});Rettighetsvakten anvender en rutes rettighet i fire trinn. En rolle i rettighetens never-liste avviser med AUTHORITY_EXCEEDED og barred-ordene, og intet sete opphever det. En rolle i roles gir adgang, med et aktivt sete i tillegg når rettigheten sier seat: true. Ellers gir et aktivt sete som bærer rettigheten adgang. Ellers avvises forespørselen med AUTHORITY_EXCEEDED, med navn på personene som kan tildele et sete. Gi vakten et lager (rights: { manifest, store: { pool, schema } }), så leser den seter under innkallerens eget omfang; en rettighet som navngir en licence trenger også en lisensleser, som dekkes nedenfor.
Inne i en behandler er scopeOf(req) den eneste måten å lese det løste omfanget på, og den kaster et unntak hvis vakten ikke kjørte. En vakt registrert på et prefiks, som kjører før noen rute har truffet, svarer med 500 MIDDLEWARE_ORDERING_ERROR; en rute koden din registrerer som manifestet ikke deklarerer, svarer med 500 UNHANDLED_ERROR. Begge feiler lukket.
Malens /internal-ruter, som plattformen kaller, bruker det andre regimet. Tjenestevakten sjekker X-Service-Key i konstant tid og henter leietakeren fra plattformens X-Organization-ID, og avviser MISSING_SERVICE_KEY, INVALID_SERVICE_KEY eller MISSING_ORG_ID_HEADER. For plattformens signerte token per kall har SDK-et requireService (Fastify) og serviceMiddleware (Express), som også sjekker hvilken ferdighet og rute tokenet ble utstedt for, og avviser et token som brukes to ganger.
Databasegjerdet: tenantFence og withScopedTx
Hver setning mot en omfangsbegrenset tabell setter sammen gjerdet og kjører inne i en omfangsbegrenset transaksjon:
import { withScopedTx } from "@adverant-nexus/plugin-sdk/runtime/db";
import { tenantFence } from "@adverant-nexus/plugin-sdk/runtime/fence";
async function listProjects(scope: ResolvedScope) {
// Projects are owner-private inside the organisation, so the owner axis is passed explicitly.
const f = tenantFence(scope, { alias: "p", owner: scope.owner });
const r = await withScopedTx(pool, scope, { schema: SCHEMA }, (db) =>
db.query(`SELECT p.* FROM anomaly_review.reviews p WHERE ${f.where} ORDER BY p.created_at DESC`, f.params),
);
return r.rows;
}tenantFence(scope, options) bygger predikatet og dets parametere fra et løst omfang. Send inn owner for personlige tabeller; utelat det for organisasjonsartefakter der eier er opphav. Når setningen allerede har parametere, forteller startIndex gjerdet hvor det skal nummereres fra. En innsetting tar aldri aksene som inndata: den skriver scope.tenant, scope.owner og scope.unit fra omfanget.
withScopedTx binder alle de tre aksene for én transaksjon gjennom skjemaets ene bindefunksjon, og kjører deretter tilbakekallet ditt. En andre binding i samme transaksjon utløser SCOPE_ALREADY_BOUND (500: koden din bandt to ganger; innkalleren gjorde ingenting galt). En fraværende eller nullstilt leietaker eller eier utløser SCOPE_PREDICATE_INVALID (403). Innstillingen er transaksjonslokal, slik at en tilkobling fra en pool ikke kan ta med seg én leietaker inn i neste forespørsel.
To søskenfunksjoner dekker tilfellene som ikke er en persons forespørsel. withTenantScopedTx binder leietaker og enhet uten eier, for rader en maskin leser (enhetsregisteret), og avviser et omfang som bærer en eier. maintenanceScope(reason) får en organisasjonsomfattende operasjon til å si høyt hva den er før eierens transaksjon åpnes. Kodegjerdet og tvungen sikkerhet på radnivå er to mekanismer for én lov; oppstartssjekken nekter å lytte før databasen beviser at den andre holder (ellers DB_ROLE_BYPASSES_ISOLATION).
Hver avvisning er en rad
Malen installerer én mellomvare til, én gang, mellom kroppsparseren og ruterne: avvisningsprotokollen.
import { recordRefusals } from "@adverant-nexus/plugin-sdk/runtime/refusal-ledger";
app.use(express.json({ limit: "256kb" }));
app.use(recordRefusals({ pool, schema: SCHEMA }));Den pakker inn svaret slik at hver avvisning en person leser, enten fra rettighetsvakten, en behandler eller et lager, skrives til skjemaets refusal-tabell inne i den personens egen omfangsbegrensede transaksjon før kroppen sendes. En anonym 401 skriver ingenting. Hvis raden ikke kan skrives, blir svaret UNHANDLED_ERROR: et «nei» produktet ikke kan loggføre, sendes ikke som om det ble det. Oppstarten kjører assertRefusalLedger for å sjekke at tabellen kan ta imot protokollens rad, og et lager kan kalle noteSubject({ recordId, isDemo }) slik at hver avvisning navngir oppføringen den gjaldt. Når en kunde spør hvorfor noen ble avvist forrige tirsdag, er svaret en spørring, ikke en gjetning.
Den ene kryssingen: en registrert skrivebeskyttet tildeling
Når en av kundene dine gjør arbeid for en annen og den andre kan inspisere det, finnes det én godkjent vei over grensen. Organisasjonen som holder radene registrerer en tildeling. Leserens organisasjon gir en person adgang gjennom et sete som bærer rettigheten granted.read, som må navngi owner og admin i never. Lesingen kjører som en sjette databaserolle, lesesetet, som kun kan velge tabellene databases[].granted lister opp:
const r = await withSeatTx({ app: appPool, seat: seatPool }, seatsOf(req), { holder, grantId }, { schema: "anomaly_review" }, (db) => {
const f = grantFence(db.seat, { alias: "r" });
return db.query(`SELECT r.review_id FROM anomaly_review.reviews r WHERE ${f.where}`, f.params);
});
if (!r.ok) return res.status(r.status).json(r.refusal);withSeatTx skriver oppslaget i leserens egen leietaker først, og binder deretter lesesetet til tildelingen, som skriver oppslaget i innehaverens leietaker. Databasens egen policy sjekker at tildelingen navngir leserens organisasjon, dekker tabellen, har startet, ikke er avsluttet og ikke er trukket tilbake, og at denne transaksjonen skrev oppslaget sitt. En lesing som hopper over oppslaget ser ingenting. Ved oppstart sjekker assertSeatAtBoot(seatPool, schema) at poolen som ble åpnet fra seat.url virkelig er setet og ikke noe mer, og avviser ellers med DB_SEAT_ROLE_INVALID.
Utsendelse gjennom UNO
All beregning går gjennom én klient, bygget i én fil, med en lukket tillatelsesliste:
import { UnoClient } from "@adverant-nexus/plugin-sdk/runtime/uno";
/** The namespaced job types this surface may dispatch. Closed; edit in code. */
export const DISPATCHABLE = Object.freeze([`${manifest.name}.sentiment_score`] as const);
export function createUno(deps: UnoDeps): UnoClient {
return new UnoClient({
baseUrl: deps.dispatchUrl,
serviceKey: deps.serviceKey,
callerService: manifest.name,
dispatchable: DISPATCHABLE,
});
}Tillatelseslisten er en konstant på modulnivå med hensikt. Hvis en operatør kunne utvide den fra konfigurasjonen, ville ruten blitt en utsendelsesproxy for hele registeret. Malens egen test bekrefter at listen navngir nøyaktig de jobbtypene manifestet kompilerer til.
Konvolutten
En utsendelse bærer seks felt i sin påkrevde kjerne. Klienten fyller ut leietaker og aktør fra det verifiserte omfanget, aldri fra forespørselen:
| Felt | Hva den inneholder |
|---|---|
jobType |
Jobbtypen med navnerom, <plugin name>.<skill id> |
organizationId |
Leietakeren, fra omfanget |
userId |
Aktøren, fra omfanget, for revisjon og fakturering |
inputParams |
Ferdighetens inndata. Den bærer aldri en leietaker-ID; en som gjør det, avvises ved utsendelse |
priority |
critical, high, normal eller low |
pluginId |
Ditt manifest name. Hver utsendelse deklarerer sin opprinnelige utvidelse |
Valgfrie felt inkluderer correlationId (en UUID (universelt unik identifikator), eller så utstedes en ny) og callbackUrl, som en plugin_queue-ferdighet trenger for at arbeideren skal vite hvor den skal sende resultatet sitt.
const accepted = await uno.dispatch(scope, {
jobType: DISPATCHABLE[0],
inputParams: { text: text.body },
priority: "normal",
pluginId: manifest.name,
correlationId: crypto.randomUUID(),
});
if (!accepted.ok) return res.status(statusFor(accepted.refusal.code)).json(accepted.refusal);
res.status(202).json(accepted.value);202, deretter spørring (polling)
Hver utsendelse legges i kø. Svaret er alltid 202 med identifikatorer (jobId, runId, traceId, status), aldri et resultat. Resultatet kommer fra spørring mot jobben eller fra tilbakekallet ditt. uno.peek(jobId, { scope }) leser det én gang og awaitJob spør helt til en sluttstatus nås; begge sender leietakeren fra det verifiserte omfanget, og begge sjekker den returnerte radens organization_id mot innkallerens leietaker på din side av nettverkskallet, og avviser et avvik med SCOPE_REFUSED.
Les kjøringsraden med dens egen stavemåte. Utsendelsessvaret sier jobId; raden sier job_id, organization_id og plugin_id. Resultat- og feilkolonnene er result, error, error_code og error_troubleshooting. completed og failed er sluttstatuser. timed_out, cancelled og system_failure kommer fra opprydderen (reaper), og et sent resultat kan fortsatt korrigere dem. En klient som behandler noen av disse som uleselige, avviser rader plattformen skriver hver dag.
Godkjenningsventingen
En manifestferdighet som deklarerer approval, settes på vent ved utsendelse. 202 sier da status: "awaiting_approval" og bærer en waitpointId, med årsaken manifestet oppga. Kjøringen forblir på vent til en navngitt person fatter en avgjørelse om den. uno.approve og uno.resolveWaitpoint sender leietakeren og innkalleren som aktør, og en avgjørelse fra noen andre enn den verifiserte innkalleren avvises. En godkjenning frigir jobben én gang og kjører utsendelsessjekkene på nytt; en avvisning avslutter den med failed. En andre avgjørelse avvises, og det samme gjør en avgjørelse etter at ventetiden har utløpt. Hvis produktet ditt krever at godkjenneren er en annen person enn forslagsstilleren, må du håndheve det i ruten som fatter avgjørelsen: plattformen registrerer begge.
Vis en jobb på vent som satt på vent. Ikke fortell en person at klikket deres frigjorde den før kjøringsraden sier det.
KI: ønsker på ferdighetsraden, og én avlesning
Utvidelsen din kaller aldri en modell. Når en manifestferdighet trenger en (llm_only eller tool_using, ved tillitsnivå core eller verified), uttrykker du preferanser på dens registerrad, og ruteren bestemmer ut fra organisasjonens egen pool:
{
"execution_config_skill": {
"preferredProvider": "gemini",
"capabilityProfile": { "needsToolUse": true, "dataResidency": "eu_only" }
}
}preferredProvider og preferredModel er ønsker ruteren kun oppfyller når organisasjonen har den leverandøren aktivert og utstyrt med legitimasjon. capabilityProfile filtrerer og velger aldri; dens dataResidency (eu_only, us_only eller any) er en absolutt begrensning ruteren enten tilfredsstiller eller avviser. Å utelate alle sammen er vanligvis riktig. modelOverride finnes for den sjeldne ferdigheten som trenger én nøyaktig modell, og den gjør ønskene ved siden av uvirksomme; jeg ville unngått den med mindre ferdigheten er meningsløs på enhver annen modell.
Når grensesnittet ditt må vise hvilken modell ruteren ville brukt, les det, ikke gjett det:
import { createAIRouteClient } from "@adverant-nexus/plugin-sdk/runtime/ai-route";createAIRouteClient(...).effectiveRoute() er den ene godkjente lesingen av KI-leverandørruteren (AI Provider Router). Den tar gatewayens adresse, innkallerens eget ihændehavertoken og plattformens slug, og sender ingen KI-forespørsel. Den svarer med leverandøren og modellen, leverandørene policyen tillater, og hvorvidt det valgte endepunktet kjører local eller external. Når ruten ikke kan brukes, svarer den med ruterens avvisning i ord (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE eller NO_MODEL_FOR_ROLE_AND_PROVIDER, med utbedringen), aldri en standardmodell. Vis den avvisningen til personen; det er organisasjonens egen konfigurasjon som taler.
Lisenskontroller
Tre mekanismer sjekker lisensiering, på tre detaljnivåer.
En rettighet som navngir en lisens. Den enkleste. I manifestet bærer en rettighet licence: "<feature>", og vakten spør identitetstjenesten om organisasjonens lisens bærer den, med innkallerens eget token, før noen rolle leses. Bygg vakten med en leser:
import { createLicenceReader } from "@adverant-nexus/plugin-sdk/runtime/licence";
const requireScope = scopeMiddleware({
verify,
rights: { manifest, store: { pool, schema: SCHEMA }, licence: createLicenceReader({ baseUrl: config.NEXUS_AUTH_URL }) },
});En lisens som ikke bærer funksjonen, avviser alle med LICENCE_LOCKED, navngir hva som bærer den, og sier at organisasjonens eiere og administratorer kan slå den på. En lisens som ikke kan leses, avviser med UNHANDLED_ERROR: en låst funksjon leveres aldri fordi lisensen var utilgjengelig. Svar huskes i 30 sekunder per organisasjon og funksjon.
Produktporten. createProductGate({ baseUrl, product }) fra runtime/product-gate spør rettighetssjekken om innkallerens organisasjon i det hele tatt har produktet ditt, og dens middleware() kjører etter omfangsvakten. En negativ kjennelse er ENTITLEMENT_DENIED; en sjekk som ikke kan nås er ENTITLEMENT_UNREACHABLE, og porten behandler aldri det ene som det andre.
Selve lisensdokumentet. Kode som må avgjøre selv ut fra den signerte lisensen, slik som den lukkede modulen i en domenepakke, bruker verifyLicenceDocument(docText, opts) fra runtime/licence-document. Det er en ren funksjon: intet nettverkskall, ingen miljøvariabel, ingen fil. Den sjekker begge signaturene mot tillitsrøttene bygget bærer, og svarer med en tilstand (VALID, WARN, GRACE, RESTRICT, TERMINATE eller ABSENT) med tildelingene, tilleggene og domenepakkene. licenceAllows(verdict, featureGroup, action, tenantId?) sier deretter om du kan kjøre use eller provision under en gruppe. RESTRICT tillater use og svarer provision med LICENCE_LOCKED, slik at pågående arbeid fortsetter og ikke noe nytt starter.
Testing
Malens tester viser mønsteret; dette er verktøyene bak det.
Omfangsetterligninger (fakes). Bygg testdubletten for det løste omfanget én gang, i test/scope-fakes.ts, og injiser den overalt, inkludert de fraværende tilfellene: ingen enhet, intet token, et token med en nullstilt organisasjon. Avvisningsstiene er selve produktet.
En falsk utsendelsestransport. UnoClient tar fetch, now og sleep, slik at en enhetstest aldri berører nettverket. Bekreft konvoluttens felt, 202-formen, spørringen frem til en sluttrad med dens organization_id, og at en rad for en annen leietaker droppes.
En ekte Postgres. En falsk spørrefunksjon beviser en SQL-streng. Den kan ikke bevise at tvungen sikkerhet på radnivå holder, eller at filene legges inn i rekkefølge som migreringsverktøyet. testing/ephemeral-postgres starter en bruk-og-kast-server og kjører den samme nexus-migrate som produksjonen kjører:
import { EPHEMERAL_REMEDY, migrated, startEphemeralPostgres } from "@adverant-nexus/plugin-sdk/testing/ephemeral-postgres";
const pg = await startEphemeralPostgres(); // null off CI: skip each case by name with EPHEMERAL_REMEDY
const db = migrated(pg!, "plugin_test", { root }); // provision as the superuser, then every file as the migrator
// connect as db.appUrl and run the boot checks the server runsUtenfor CI (kontinuerlig integrasjon) hopper en maskin uten Postgres-server over hvert databasetilfelle ved navn med løsningen oppgitt, aldri grønt. I CI gjør det samme fraværet at testpakken feiler (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), fordi en overhoppet test for sikkerhet på radnivå er en grønn port som ikke målte noenting. Serveren venter opptil 180 sekunder på å starte, og en vaktbikkje (watchdog) stopper den når testprosessen forsvinner.
Isolasjonsselen. runIsolationHarness(target) fra testing/isolation-harness leser hver rute appen din monterer, og angriper hver enkelt som en annen organisasjons administrator og som en kollega. Deretter angriper den igjen med kodegjerdet fjernet, databasegjerdet fjernet, og begge fjernet. En rute er PROVEN kun når angrepet feiler med et av gjerdene på plass og når frem til offerets data når begge er fjernet, slik at du vet at testen i det hele tatt kan se en lekkasje. Den sender hver rutes deklarerte spørring og eksempelkropp, slik at en rute som avviser en tom forespørsel likevel nås. Lås ledgerOf(report) i en test og la den feile på defectsOf(report).
Registrering: fra manifest til ferdighetsregister
Manifestferdighetene dine når ferdighetsregisteret via én vei:
manifest.skills[] → compileRegistry(manifest) → POST /api/v1/plugins/sync
compileRegistry gjør et validert manifest om til nexus.plugin-sync/v1-kroppen. Malen gjør det ved import, slik at et ugyldig manifest gjør at bygget feiler:
import { compileRegistry, definePlugin } from "@adverant-nexus/plugin-sdk";
export const manifest = definePlugin(raw);
export const registryPayload = compileRegistry(manifest);{
"contract": "nexus.plugin-sync/v1",
"pluginId": "anomaly-review",
"version": "0.3.0",
"skills": [ { "job_type": "anomaly-review.excursion_summary", "tier": "host_callback", "classification": "tenant" } ]
}Synkroniseringen er deklarativ: send hele ferdighetssettet hver gang, og en ferdighet som er utelatt blir deaktivert, med historikken beholdt. Den er streng: et ukjent felt, et felt fra et annet nivå eller en null avvises, alle brudd kommer tilbake sammen i én 400 SYNC_CONTRACT_VIOLATION, og ingenting skrives så lenge det finnes ett. Og den skriver én registerrad per ferdighet, nøklet på jobbtypen med navnerom, med hver kolonne utsenderen leser, slik at ferdigheten er kjørbar i det øyeblikket synkroniseringen svarer 200.
Utvidelsen er den autentiserte innkalleren, aldri et felt i kroppen. Kall synkroniseringen fra utvidelsens egen arbeidsbelastning over mTLS (gjensidig TLS: Transport Layer Security med et sertifikat i begge ender). Ferdighetsmotoren (Skills Engine) leser arbeidsbelastningens klientsertifikat, hvis SPIFFE-identitet (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) navngir navnerommet og tjenestekontoen, og slår opp utvidelsen og eierorganisasjonen som er registrert for det navnerommet. Kroppens pluginId må samsvare; det er en sjekk, ikke en velger. Hver rad skrives med den utvidelsen og organisasjonen.
| Status | Kode | Betydning |
|---|---|---|
| 200 | {contract, pluginId, version, created, updated, unchanged, disabled, skills} |
|
| 400 | SYNC_CONTRACT_VIOLATION |
Hvert brudd er listet opp i violations[]; ingenting ble skrevet |
| 401 | UNAUTHORIZED |
Ugyldig eller manglende tjenestenøkkel |
| 401 | CALLER_IDENTITY_UNVERIFIED |
Ingen lesbar klientidentitet |
| 403 | DELIVERY_IDENTITY_MISSING |
Det kallende navnerommet tilhører ingen utvidelse |
| 403 | PLUGIN_ID_MISMATCH |
Kroppen navngir en annen utvidelse |
| 409 | REGISTRY_CONFLICT |
En jobbtype eies et annet sted eller ble registrert utenfor synkroniseringen; ingenting ble skrevet |
La utrullingstrinnet ditt feile ved enhver annen status enn 200. Ingen annen status betyr at ferdighetene dine er registrert.
Klargjøring
Innføringen kjører som ti ordnede trinn, der hvert enkelt kan kjøres på nytt, avbrytes eller rulles tilbake på egen hånd:
- Klon kodelageret og valider det.
- Analyser manifestet.
- Skann det etter sikkerhetsproblemer.
- Bygg avbildningen (image).
- Send den til installasjonens register.
- Sett opp domenenavnene dens.
- Rull den ut gjennom installasjonens utgivelseskanaler.
- Vent på helsesjekken.
- Registrer utvidelsen.
- Varsle utvikleren.
Før utrulling kjører fem samsvarssjekker mot manifestet og den bygde avbildningen: manifestet lar seg analysere og bærer sine påkrevde felt; hver deklarerte rute er en reell registrert rute; utvidelsen eier sitt skjema og skriver ingenting utenfor det; ressursforespørsler er deklarert og innenfor grensene; og avbildningen har en fungerende helsebehandler. En utvidelse som registrerer seg selv ved oppstart, kjører den samme kontrakten under sin egen autoritet, slik at sjekkene blir dens CI i stedet for rørledningens (pipeline). Å hoppe over én forkorter ikke innføringen; det flytter feilen til kjøretiden.
Merkevarebyggingen i manifestet ditt leveres uten autentisering per domene, fordi påloggingssiden trenger den før noen har legitimasjon. Behandle alt i branding som offentlig.
GATE_CANNOT_BE_SKIPPED.Hva kjøremiljøet ikke gjør for deg
Kjøretidsmiljøet holder linjen når det gjelder isolasjon, utsendelse og modelltilgang. Det vil ikke gjøre produktlogikken din riktig, og det vil ikke gjøre en treg spørring rask: hver setning kjører inne i en bundet transaksjon med tidsavbruddene manifestets db-blokk deklarerer, og en setning som overskrider statementTimeoutMs blir avbrutt, ikke ventet på. Dimensjoner spørringene dine etter det. Og godkjenningsventingen, lesesetet og lisensleseren legger alle til en rundtur eller en transaksjon. På min utvidelse for avviksgjennomgang la lisenssjekken til noen få millisekunder per forespørsel frem til 30-sekundersminnet ble varmt, noe som var en rimelig pris å betale for aldri å levere en låst funksjon.

