@northstartech/cipher 0.0.0-stage → 1.0.0

package/dist/integrations/prisma.d.ts

@@ -0,0 +1,65 @@
+import type { NorthstarCipher } from '../client.js';
+import { CipherError } from '../errors.js';
+import { type CipherIntegrationOptions, type EncryptedFieldSpec, type IdGeneratorName } from './shared.js';
+import type { SearchDocument } from '../search.js';
+export { CIPHERTEXT_PREFIX, PENDING_SENTINEL } from './shared.js';
+export type { EncryptedFieldOptions, EncryptedFieldSpec, CipherIntegrationOptions } from './shared.js';
+/**
+ * How the record id is obtained when `data` does not contain it:
+ * * `'sequence'`: reserve from the PostgreSQL serial/identity sequence (`nextval(pg_get_serial_sequence(…))`);
+ * * `'uuid' | 'uuidv7' | 'cuid' | 'cuid2' | 'ulid' | 'nanoid'`: generate client-side;
+ * * `'explicit'`: the application always supplies the id;
+ * * a function returning a new id.
+ *
+ * Default: `'uuid'` for `String` ids, `'sequence'` for `Int`/`BigInt` ids on
+ * PostgreSQL/CockroachDB. Integer ids on other databases are a configuration
+ * error (the id is unknown before the insert): use a client-generated id.
+ */
+export type PrismaIdStrategy = 'sequence' | 'explicit' | IdGeneratorName | (() => string | number | bigint);
+export interface PrismaIdConfig {
+    /** Primary-key field. Default `id`. Composite keys are not supported. */
+    field?: string;
+    strategy?: PrismaIdStrategy;
+}
+/** Per-model config: `{ title: true, email: { searchable: 'email' }, $id?: … }`. */
+export type PrismaModelCipherConfig = {
+    $id?: PrismaIdConfig | PrismaIdStrategy;
+} & {
+    [field: string]: EncryptedFieldSpec | PrismaIdConfig | PrismaIdStrategy | undefined;
+};
+export interface NorthstarPrismaOptions extends CipherIntegrationOptions {
+    /** Encrypted fields per model (Prisma model names, e.g. `Todo`). */
+    models: Record<string, PrismaModelCipherConfig>;
+}
+/** `where` fragment produced by `cipherWhere`: `{ email_bidx: { in: [...] } }`. */
+export type CipherWhere = Record<string, {
+    in: string[];
+}>;
+/**
+ * Create the Prisma Client extension. Apply it with `prisma.$extends(...)`.
+ * The returned value also exposes `cipherWhere(model, field, value)`.
+ */
+export declare function withNorthstarCipher(cipher: NorthstarCipher, options: NorthstarPrismaOptions): ((client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/client").InternalArgs<{}, {
+    $allModels: {
+        /** Exact-match `where` fragment for a searchable encrypted field: `{ <field>_bidx: { in: tokens } }`. */
+        cipherWhere<T>(this: T, field: string, value: string | string[]): Promise<CipherWhere>;
+        /** Northstar Search documents for rows of this model (see `searchDocuments` on the extension). */
+        cipherSearchDocuments<T>(this: T, rows: Record<string, unknown>[], fields: string[]): SearchDocument[];
+    };
+}, {}, {}> & import("@prisma/client/runtime/client").DefaultArgs>) & {
+    /**
+     * Exact-match filter for a searchable encrypted field:
+     * `await nsc.cipherWhere('Todo', 'email', 'ana@example.com')` → `{ email_bidx: { in: [...] } }`.
+     * Spread it into `where`. Requires the extension to be applied to a client first.
+     */
+    cipherWhere(model: string, field: string, value: string | string[]): Promise<CipherWhere>;
+    /**
+     * Northstar Search documents for rows of `model`. Rows read with the base
+     * client (`new PrismaClient()` without the extension, or raw SQL keyed by
+     * field name) hold stored ciphertext, which is sent with the context it is
+     * bound to and decrypted inside the enclave: indexing needs no decrypt
+     * request. Rows read through the extension hold plaintext, which is sent as is.
+     */
+    searchDocuments(model: string, rows: Record<string, unknown>[], fields: string[]): SearchDocument[];
+};
+export { CipherError };

package/dist/integrations/prisma.js

@@ -0,0 +1,588 @@
+/**
+ * Prisma Client extension: transparent field-level encryption for Prisma models.
+ *
+ * ```ts
+ * import { PrismaClient } from './generated/prisma/client.js'
+ * import { NorthstarCipher } from '@northstartech/cipher'
+ * import { withNorthstarCipher } from '@northstartech/cipher/prisma'
+ *
+ * const cipher = NorthstarCipher.fromEnv()
+ * const nsc = withNorthstarCipher(cipher, { models: { Todo: { title: true, email: { searchable: 'email' } } } })
+ * const prisma = new PrismaClient({ adapter }).$extends(nsc)
+ *
+ * await prisma.todo.create({ data: { title: 'Buy milk', email: 'Ana@example.com' } })
+ * const todos = await prisma.todo.findMany()                         // one decrypt request per query
+ * const mine = await prisma.todo.findMany({ where: await prisma.todo.cipherWhere('email', 'ana@example.com') })
+ *
+ * // Northstar Search: index rows read with the base client (stored ciphertext, decrypted inside the enclave)
+ * await cipher.index('todos').upsert(nsc.searchDocuments('Todo', await base.todo.findMany(), ['title', 'email', 'done']))
+ * ```
+ *
+ * Writes encrypt `data` before the statement is sent (one batch per operation),
+ * reads decrypt every encrypted field of every returned row (including nested
+ * `include`/`select` relations) in one batch. See README "Prisma".
+ */
+import { Prisma } from '@prisma/client/extension';
+import { CipherError } from '../errors.js';
+import { ID_GENERATORS, INDEX_SUFFIX, RESERVE_IDS_SQL, configError, decryptValues, encryptValues, isIdGeneratorName, normalizeFieldSpec, plaintextOf, qualifiedTable, recordIdOf, requestError, reservedIdsFrom, searchDocumentOf, searchTokensFor, } from './shared.js';
+export { CIPHERTEXT_PREFIX, PENDING_SENTINEL } from './shared.js';
+const READ_OPS = new Set(['findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow', 'findMany']);
+const RETURNING_WRITE_OPS = new Set(['create', 'update', 'upsert', 'delete', 'createManyAndReturn', 'updateManyAndReturn']);
+const NESTED_WRITE_KEYS = ['create', 'createMany', 'connectOrCreate', 'update', 'updateMany', 'upsert'];
+const NULL_ONLY_FILTER_KEYS = new Set(['equals', 'not', 'isSet']);
+function lowerFirst(s) {
+    return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function isPlainObject(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const p = Object.getPrototypeOf(v);
+    return p === Object.prototype || p === null;
+}
+function asArray(v) {
+    return v === undefined || v === null ? [] : Array.isArray(v) ? v : [v];
+}
+/** Resolve and validate the configuration against the client's runtime data model. */
+function resolveSchema(options, client) {
+    const c = client;
+    const models = c._runtimeDataModel?.models;
+    if (!models)
+        throw configError('Prisma: could not read the client data model (unsupported Prisma version?)');
+    const provider = String(c._activeProvider ?? '');
+    if (!options || typeof options !== 'object' || !options.models || typeof options.models !== 'object') {
+        throw configError('Prisma: withNorthstarCipher(cipher, { models: { Model: { field: true } } }) requires a models map');
+    }
+    const relations = new Map();
+    for (const [name, m] of Object.entries(models)) {
+        relations.set(name, new Map(m.fields.filter((f) => f.kind === 'object').map((f) => [f.name, f.type])));
+    }
+    const plans = new Map();
+    for (const [model, cfg] of Object.entries(options.models)) {
+        const rm = models[model];
+        if (!rm)
+            throw configError(`Prisma: unknown model "${model}" (use the model name from schema.prisma, e.g. "Todo")`);
+        if (!cfg || typeof cfg !== 'object')
+            throw configError(`Prisma: config for ${model} must be an object of encrypted fields`);
+        const byName = new Map(rm.fields.map((f) => [f.name, f]));
+        const idCfg = typeof cfg.$id === 'string' || typeof cfg.$id === 'function' ? { strategy: cfg.$id } : (cfg.$id ?? {});
+        const idField = idCfg.field ?? 'id';
+        const idf = byName.get(idField);
+        if (!idf || idf.kind !== 'scalar') {
+            throw configError(`Prisma: ${model} has no scalar "${idField}" field. Set $id: { field: '<primary key>' } (composite primary keys are not supported for encrypted models)`);
+        }
+        if (idf.type !== 'String' && idf.type !== 'Int' && idf.type !== 'BigInt')
+            throw configError(`Prisma: ${model}.${idField} must be String, Int or BigInt to bind ciphertext to it`);
+        const idType = idf.type;
+        let strategy;
+        const pgLike = provider === 'postgresql' || provider === 'cockroachdb';
+        if (idCfg.strategy !== undefined) {
+            strategy = idCfg.strategy;
+            if (typeof strategy !== 'function' && strategy !== 'sequence' && strategy !== 'explicit' && !isIdGeneratorName(strategy)) {
+                throw configError(`Prisma: ${model}.$id strategy "${String(strategy)}" is not supported`);
+            }
+            if (strategy === 'sequence' && !pgLike)
+                throw configError(`Prisma: ${model}.$id strategy "sequence" requires PostgreSQL (provider is ${provider})`);
+            if (strategy === 'sequence' && idType === 'String')
+                throw configError(`Prisma: ${model}.${idField} is a String; "sequence" needs an integer key`);
+            if (isIdGeneratorName(strategy) && idType !== 'String')
+                throw configError(`Prisma: ${model}.${idField} is ${idType}; "${strategy}" generates strings`);
+        }
+        else if (idType === 'String')
+            strategy = 'uuid';
+        else if (pgLike)
+            strategy = 'sequence';
+        else {
+            throw configError(`Prisma: ${model}.${idField} is an auto-increment ${idType} on ${provider}, so the record id is unknown before the insert. ` +
+                `Use a client-generated String id (@default(uuid()) / cuid()), or set $id: 'explicit' and always pass ids`);
+        }
+        const fields = [];
+        for (const [attr, spec] of Object.entries(cfg)) {
+            if (attr === '$id')
+                continue;
+            const label = `Prisma: ${model}.${attr}`;
+            const f = byName.get(attr);
+            if (!f)
+                throw configError(`${label}: no such field`);
+            if (f.kind !== 'scalar' || f.type !== 'String')
+                throw configError(`${label}: encrypted fields must be String scalars (the column stores nsc:v1:… text)`);
+            if (attr === idField)
+                throw configError(`${label}: the primary key cannot be encrypted`);
+            const n = normalizeFieldSpec(spec, label);
+            let indexAttr;
+            if (n.searchable) {
+                indexAttr = n.indexField ?? [`${attr}${INDEX_SUFFIX}`, `${attr}Bidx`].find((k) => byName.has(k));
+                const idx = indexAttr ? byName.get(indexAttr) : undefined;
+                if (!indexAttr || !idx)
+                    throw configError(`${label}: searchable fields need a blind-index field (add \`${attr}${INDEX_SUFFIX} String? @db.VarChar(64)\` with an index, or set indexField)`);
+                if (idx.kind !== 'scalar' || idx.type !== 'String')
+                    throw configError(`${label}: index field ${indexAttr} must be a String scalar`);
+            }
+            fields.push({ attr, column: f.dbName ?? f.name, ...(n.normalization ? { normalization: n.normalization } : {}), ...(indexAttr ? { indexAttr } : {}) });
+        }
+        if (!fields.length)
+            throw configError(`Prisma: ${model} lists no encrypted fields`);
+        plans.set(model, {
+            model,
+            table: rm.dbName ?? model,
+            schema: rm.schema ?? null,
+            idField,
+            idColumn: idf.dbName ?? idf.name,
+            idType,
+            strategy,
+            fields,
+            byAttr: new Map(fields.map((f) => [f.attr, f])),
+            indexAttrs: new Set(fields.flatMap((f) => (f.indexAttr ? [f.indexAttr] : []))),
+            scalars: new Set(rm.fields.filter((f) => f.kind === 'scalar' || f.kind === 'enum').map((f) => f.name)),
+        });
+    }
+    return { plans, relations, provider };
+}
+function signature(s) {
+    return JSON.stringify([...s.plans.values()].map((p) => [p.model, p.table, p.idField, p.fields.map((f) => [f.attr, f.column, f.indexAttr ?? ''])]));
+}
+/**
+ * Create the Prisma Client extension. Apply it with `prisma.$extends(...)`.
+ * The returned value also exposes `cipherWhere(model, field, value)`.
+ */
+export function withNorthstarCipher(cipher, options) {
+    if (!cipher || typeof cipher.encryptManySettled !== 'function') {
+        throw configError('Prisma: withNorthstarCipher(cipher, options) requires a NorthstarCipher client');
+    }
+    const decryptOpts = { purpose: options?.purpose, readLegacyPlaintext: options?.readLegacyPlaintext === true };
+    const keyOpts = { keyId: options?.keyId };
+    let applied;
+    let ambiguous = false;
+    async function tokensWhere(schema, model, field, value) {
+        const plan = schema.plans.get(model);
+        const f = plan?.byAttr.get(field);
+        if (!plan || !f)
+            throw configError(`Prisma: ${model}.${field} is not an encrypted field`);
+        if (!f.indexAttr)
+            throw configError(`Prisma: ${model}.${field} is not searchable (set { searchable: … })`);
+        const tokens = await searchTokensFor(cipher, {
+            collection: plan.table,
+            field: f.column,
+            normalization: f.normalization,
+            values: value,
+            keyId: keyOpts.keyId,
+            label: `${plan.table}.${f.column}`,
+        });
+        return { [f.indexAttr]: { in: tokens } };
+    }
+    function searchDocs(schema, model, rows, fields) {
+        const plan = schema.plans.get(model);
+        if (!plan)
+            throw configError(`Prisma: ${model} is not configured for Northstar Cipher`);
+        const plans = fields.map((attr) => {
+            if (!plan.scalars.has(attr))
+                throw configError(`Prisma: ${model}.${attr} is not a scalar field`);
+            const f = plan.byAttr.get(attr);
+            return { attr, ...(f ? { encrypted: { collection: plan.table, field: f.column } } : {}) };
+        });
+        return rows.map((row) => searchDocumentOf(row, { id: row[plan.idField], fields: plans, label: `${plan.model}` }));
+    }
+    const extension = Prisma.defineExtension((client) => {
+        const schema = resolveSchema(options, client);
+        if (applied && signature(applied) !== signature(schema))
+            ambiguous = true;
+        applied ??= schema;
+        const base = client;
+        const newIds = async (plan, n) => {
+            const s = plan.strategy;
+            if (s === 'sequence') {
+                const rows = await base.$queryRawUnsafe(RESERVE_IDS_SQL, qualifiedTable(plan.table, plan.schema), plan.idColumn, n);
+                return reservedIdsFrom(rows, n, `${plan.model}.${plan.idField}`).map((v) => (plan.idType === 'BigInt' ? BigInt(v) : Number(v)));
+            }
+            if (s === 'explicit')
+                throw requestError(`${plan.model}.${plan.idField} must be provided when writing encrypted fields ($id strategy 'explicit')`);
+            if (typeof s === 'function')
+                return Array.from({ length: n }, () => s());
+            return Array.from({ length: n }, () => ID_GENERATORS[s]());
+        };
+        /** Encrypt the encrypted fields of `rows` (each bound to its id) in one batch, in place. */
+        const encryptRows = async (plan, rows, op) => {
+            const items = [];
+            const targets = [];
+            for (const { data, id } of rows) {
+                for (const f of plan.fields) {
+                    if (!(f.attr in data) || data[f.attr] === undefined)
+                        continue;
+                    let v = data[f.attr];
+                    if (isPlainObject(v)) {
+                        const keys = Object.keys(v);
+                        if (op !== 'update' || keys.length !== 1 || keys[0] !== 'set')
+                            throw requestError(`${plan.model}.${f.attr}: only direct values (or { set }) can be written to encrypted fields`);
+                        v = v.set;
+                    }
+                    if (v === null) {
+                        data[f.attr] = null;
+                        if (f.indexAttr)
+                            data[f.indexAttr] = null;
+                        continue;
+                    }
+                    const label = `${plan.model}.${f.attr}`;
+                    items.push({ collection: plan.table, field: f.column, recordId: recordIdOf(id, label), plaintext: plaintextOf(v, label), normalization: f.normalization, label });
+                    targets.push({ data, f });
+                }
+            }
+            const enc = await encryptValues(cipher, items, keyOpts);
+            enc.forEach((e, i) => {
+                const { data, f } = targets[i];
+                data[f.attr] = e.ciphertext;
+                if (f.indexAttr)
+                    data[f.indexAttr] = e.index ?? null;
+            });
+        };
+        const touches = (plan, data) => {
+            if (!plan || !isPlainObject(data))
+                return false;
+            for (const k of plan.indexAttrs) {
+                if (data[k] !== undefined)
+                    throw requestError(`${plan.model}.${k} is the blind index of an encrypted field and is managed by Northstar Cipher`);
+            }
+            return plan.fields.some((f) => data[f.attr] !== undefined);
+        };
+        /** Nested writes into encrypted models bypass the extension: refuse them (fail closed). */
+        const assertNestedWrites = (model, data) => {
+            if (!isPlainObject(data))
+                return;
+            const rels = schema.relations.get(model);
+            if (!rels)
+                return;
+            for (const [rel, target] of rels) {
+                const ops = data[rel];
+                if (!isPlainObject(ops))
+                    continue;
+                for (const key of NESTED_WRITE_KEYS) {
+                    for (const entry of asArray(ops[key])) {
+                        const payloads = [];
+                        if (key === 'create')
+                            payloads.push(entry);
+                        else if (key === 'createMany')
+                            payloads.push(...asArray(entry?.data));
+                        else if (key === 'connectOrCreate')
+                            payloads.push(entry?.create);
+                        else if (key === 'upsert')
+                            payloads.push(entry?.create, entry?.update);
+                        else if (isPlainObject(entry) && 'data' in entry && Object.keys(entry).every((k) => k === 'data' || k === 'where'))
+                            payloads.push(entry.data);
+                        else
+                            payloads.push(entry);
+                        for (const p of payloads) {
+                            const tp = schema.plans.get(target);
+                            if (touches(tp, p)) {
+                                throw requestError(`${model}.${rel}: nested ${key} into ${target} would write encrypted fields without encryption; write ${target} through prisma.${lowerFirst(target)} instead`);
+                            }
+                            assertNestedWrites(target, p);
+                        }
+                    }
+                }
+            }
+        };
+        /** Filters, ordering and grouping cannot work on ciphertext: refuse them instead of silently returning nothing. */
+        const assertWhere = (model, where) => {
+            if (!isPlainObject(where))
+                return;
+            const plan = schema.plans.get(model);
+            const rels = schema.relations.get(model);
+            for (const [k, v] of Object.entries(where)) {
+                if (k === 'AND' || k === 'OR' || k === 'NOT') {
+                    for (const w of asArray(v))
+                        assertWhere(model, w);
+                }
+                else if (plan?.byAttr.has(k)) {
+                    const nullOnly = v === null || (isPlainObject(v) && Object.entries(v).every(([op, x]) => NULL_ONLY_FILTER_KEYS.has(op) && (x === null || typeof x === 'boolean')));
+                    if (!nullOnly) {
+                        const f = plan.byAttr.get(k);
+                        throw requestError(`${model}.${k} is encrypted: only null checks can filter it` + (f.indexAttr ? ` (use cipherWhere('${model}', '${k}', value) for exact match)` : ''));
+                    }
+                }
+                else if (rels?.has(k) && isPlainObject(v)) {
+                    const target = rels.get(k);
+                    const nested = ['some', 'every', 'none', 'is', 'isNot'].filter((x) => x in v);
+                    if (nested.length)
+                        for (const x of nested)
+                            assertWhere(target, v[x]);
+                    else
+                        assertWhere(target, v);
+                }
+            }
+        };
+        const assertOrder = (model, orderBy) => {
+            const plan = schema.plans.get(model);
+            const rels = schema.relations.get(model);
+            for (const o of asArray(orderBy)) {
+                if (!isPlainObject(o))
+                    continue;
+                for (const [k, v] of Object.entries(o)) {
+                    if (plan?.byAttr.has(k))
+                        throw requestError(`${model}.${k} is encrypted: ordering by it is not supported`);
+                    if (rels?.has(k))
+                        assertOrder(rels.get(k), v);
+                }
+            }
+        };
+        const assertFieldList = (model, what, v) => {
+            const plan = schema.plans.get(model);
+            if (!plan)
+                return;
+            const keys = Array.isArray(v) ? v.map(String) : isPlainObject(v) ? Object.keys(v).filter((k) => v[k]) : typeof v === 'string' ? [v] : [];
+            const bad = keys.find((k) => plan.byAttr.has(k));
+            if (bad)
+                throw requestError(`${model}.${bad} is encrypted: ${what} is not supported on encrypted fields`);
+        };
+        /** Copy-on-write the selection so encrypted fields always come back with their id; returns the result shape. */
+        const shapeOf = (model, a) => {
+            const shape = { model, injectedId: false, children: new Map() };
+            if (!isPlainObject(a))
+                return { shape, args: a };
+            const plan = schema.plans.get(model);
+            const rels = schema.relations.get(model) ?? new Map();
+            const out = { ...a };
+            assertWhere(model, a.where);
+            assertOrder(model, a.orderBy);
+            if (a.distinct !== undefined)
+                assertFieldList(model, 'distinct', a.distinct);
+            for (const key of ['select', 'include']) {
+                const sel = a[key];
+                if (!isPlainObject(sel))
+                    continue;
+                const copy = { ...sel };
+                for (const [k, v] of Object.entries(sel)) {
+                    const target = rels.get(k);
+                    if (target && v) {
+                        const r = shapeOf(target, v);
+                        shape.children.set(k, r.shape);
+                        copy[k] = r.args;
+                    }
+                }
+                if (key === 'select' && plan && plan.fields.some((f) => copy[f.attr]) && !copy[plan.idField]) {
+                    copy[plan.idField] = true;
+                    shape.injectedId = true;
+                }
+                out[key] = copy;
+            }
+            if (isPlainObject(a.omit) && plan && a.omit[plan.idField] && plan.fields.some((f) => !a.omit[f.attr])) {
+                out.omit = { ...a.omit, [plan.idField]: false };
+                shape.injectedId = true;
+            }
+            return { shape, args: out };
+        };
+        const decryptResult = async (shape, result) => {
+            if (!shape || result === null || result === undefined)
+                return;
+            const items = [];
+            const targets = [];
+            const strip = [];
+            const walk = (s, v) => {
+                if (Array.isArray(v))
+                    return v.forEach((x) => walk(s, x));
+                if (!v || typeof v !== 'object')
+                    return;
+                const obj = v;
+                const plan = schema.plans.get(s.model);
+                if (plan) {
+                    const present = plan.fields.filter((f) => f.attr in obj);
+                    if (present.length) {
+                        const label = `${plan.model}.${present[0].attr}`;
+                        const recordId = present.some((f) => obj[f.attr] !== null && obj[f.attr] !== undefined) ? recordIdOf(obj[plan.idField], label) : '';
+                        for (const f of present) {
+                            items.push({ collection: plan.table, field: f.column, recordId, stored: obj[f.attr], label: `${plan.model}.${f.attr} (${plan.idField}=${recordId})` });
+                            targets.push({ obj, attr: f.attr });
+                        }
+                    }
+                    if (s.injectedId)
+                        strip.push({ obj, attr: plan.idField });
+                }
+                for (const [rel, child] of s.children)
+                    if (rel in obj)
+                        walk(child, obj[rel]);
+            };
+            walk(shape, result);
+            const plain = await decryptValues(cipher, items, decryptOpts);
+            plain.forEach((p, i) => {
+                const t = targets[i];
+                t.obj[t.attr] = p;
+            });
+            for (const s of strip)
+                delete s.obj[s.attr];
+        };
+        const resolveId = async (plan, jsModel, where, required) => {
+            if (isPlainObject(where)) {
+                const w = where[plan.idField];
+                if (w !== undefined && w !== null && !isPlainObject(w))
+                    return w;
+            }
+            const delegate = base[jsModel];
+            const row = required
+                ? await delegate.findUniqueOrThrow({ where, select: { [plan.idField]: true } })
+                : await delegate.findUnique({ where, select: { [plan.idField]: true } });
+            return row ? row[plan.idField] : undefined;
+        };
+        return client.$extends({
+            name: 'northstar-cipher',
+            model: {
+                $allModels: {
+                    /** Exact-match `where` fragment for a searchable encrypted field: `{ <field>_bidx: { in: tokens } }`. */
+                    async cipherWhere(field, value) {
+                        const ctx = Prisma.getExtensionContext(this);
+                        return tokensWhere(schema, String(ctx.$name), field, value);
+                    },
+                    /** Northstar Search documents for rows of this model (see `searchDocuments` on the extension). */
+                    cipherSearchDocuments(rows, fields) {
+                        const ctx = Prisma.getExtensionContext(this);
+                        return searchDocs(schema, String(ctx.$name), rows, fields);
+                    },
+                },
+            },
+            query: {
+                $allModels: {
+                    async $allOperations(params) {
+                        const { model, operation, args, query } = params;
+                        // `dataPath` (fluent API) and `jsModelName` are not in Prisma's public callback type.
+                        const internal = params.__internalParams;
+                        const jsModel = internal?.jsModelName ?? lowerFirst(model);
+                        const plan = schema.plans.get(model);
+                        let a = (args ?? {});
+                        let reservedId = false;
+                        if (operation === 'groupBy' || operation === 'aggregate') {
+                            assertWhere(model, a.where);
+                            assertOrder(model, a.orderBy);
+                            if (a.by !== undefined)
+                                assertFieldList(model, 'groupBy', a.by);
+                            for (const k of ['_min', '_max'])
+                                if (a[k] !== undefined)
+                                    assertFieldList(model, k, a[k]);
+                            return query(args);
+                        }
+                        if (operation === 'count' || operation === 'deleteMany') {
+                            assertWhere(model, a.where);
+                            return query(args);
+                        }
+                        // Writes: encrypt before the statement is built.
+                        if (operation === 'create' || operation === 'createMany' || operation === 'createManyAndReturn') {
+                            const rows = asArray(a.data).map((d) => {
+                                assertNestedWrites(model, d);
+                                return isPlainObject(d) ? { ...d } : d;
+                            });
+                            if (plan) {
+                                const todo = rows.filter((d) => touches(plan, d));
+                                const missing = todo.filter((d) => d[plan.idField] === undefined || d[plan.idField] === null);
+                                reservedId = missing.length > 0 && plan.strategy === 'sequence';
+                                const ids = missing.length ? await newIds(plan, missing.length) : [];
+                                missing.forEach((d, i) => (d[plan.idField] = ids[i]));
+                                await encryptRows(plan, todo.map((d) => ({ data: d, id: d[plan.idField] })), operation);
+                            }
+                            a = { ...a, data: Array.isArray(a.data) ? rows : rows[0] };
+                        }
+                        else if (operation === 'update' || operation === 'updateMany' || operation === 'updateManyAndReturn') {
+                            assertNestedWrites(model, a.data);
+                            assertWhere(model, a.where);
+                            if (plan && isPlainObject(a.data)) {
+                                const data = { ...a.data };
+                                if (data[plan.idField] !== undefined)
+                                    throw requestError(`${model}.${plan.idField}: changing the primary key would invalidate the record's ciphertext`);
+                                if (touches(plan, data)) {
+                                    if (operation !== 'update') {
+                                        throw requestError(`${model}.${operation} cannot write encrypted fields (each record needs its own ciphertext); update records individually`);
+                                    }
+                                    const id = await resolveId(plan, jsModel, a.where, true);
+                                    await encryptRows(plan, [{ data, id }], 'update');
+                                    a = { ...a, data, where: { ...a.where, [plan.idField]: id } };
+                                }
+                            }
+                        }
+                        else if (operation === 'upsert') {
+                            assertNestedWrites(model, a.create);
+                            assertNestedWrites(model, a.update);
+                            assertWhere(model, a.where);
+                            if (plan) {
+                                const create = isPlainObject(a.create) ? { ...a.create } : a.create;
+                                const update = isPlainObject(a.update) ? { ...a.update } : a.update;
+                                if (isPlainObject(update) && update[plan.idField] !== undefined) {
+                                    throw requestError(`${model}.${plan.idField}: changing the primary key would invalidate the record's ciphertext`);
+                                }
+                                const tc = touches(plan, create);
+                                const tu = touches(plan, update);
+                                if (tc || tu) {
+                                    const c = create;
+                                    if (c[plan.idField] === undefined || c[plan.idField] === null) {
+                                        c[plan.idField] = (await newIds(plan, 1))[0];
+                                        reservedId = plan.strategy === 'sequence';
+                                    }
+                                    const existing = await resolveId(plan, jsModel, a.where, false);
+                                    const updateId = existing ?? c[plan.idField];
+                                    await encryptRows(plan, [
+                                        ...(tc ? [{ data: c, id: c[plan.idField] }] : []),
+                                        ...(tu ? [{ data: update, id: updateId }] : []),
+                                    ], 'update');
+                                    // Pin the target so the update branch can only hit the record its ciphertext is bound to.
+                                    a = { ...a, create: c, update, where: { ...a.where, [plan.idField]: updateId } };
+                                }
+                            }
+                        }
+                        else if (operation === 'delete') {
+                            assertWhere(model, a.where);
+                        }
+                        else if (!READ_OPS.has(operation)) {
+                            return query(args);
+                        }
+                        // Reads (and writes that return rows): decrypt in one batch.
+                        const { shape, args: shaped } = shapeOf(model, a);
+                        let result;
+                        try {
+                            result = await query(shaped);
+                        }
+                        catch (e) {
+                            // Prisma's "checked" create input (relation fields such as `owner: { connect }`) has no slot for an
+                            // auto-increment id, so the reserved id cannot be passed. Nothing was written; explain the fix.
+                            if (reservedId && plan && e instanceof Error && e.message.includes(`Unknown argument \`${plan.idField}\``)) {
+                                throw requestError(`${model}.${operation}: the reserved ${plan.idField} cannot be combined with relation inputs (e.g. \`owner: { connect }\`). ` +
+                                    `Set the foreign-key scalar instead (e.g. ownerId), or use a client-generated String id`);
+                            }
+                            throw e;
+                        }
+                        if (READ_OPS.has(operation) || RETURNING_WRITE_OPS.has(operation)) {
+                            let s = shape;
+                            const path = internal?.dataPath ?? [];
+                            for (let i = 1; i < path.length && s; i += 2)
+                                s = s.children.get(path[i]);
+                            await decryptResult(s, result);
+                        }
+                        return result;
+                    },
+                },
+            },
+        });
+    });
+    return Object.assign(extension, {
+        /**
+         * Exact-match filter for a searchable encrypted field:
+         * `await nsc.cipherWhere('Todo', 'email', 'ana@example.com')` → `{ email_bidx: { in: [...] } }`.
+         * Spread it into `where`. Requires the extension to be applied to a client first.
+         */
+        async cipherWhere(model, field, value) {
+            if (!applied)
+                throw configError('Prisma: apply the extension (prisma.$extends(...)) before calling cipherWhere');
+            if (ambiguous)
+                throw configError('Prisma: the extension is applied to clients with different schemas; use prisma.<model>.cipherWhere(field, value)');
+            return tokensWhere(applied, model, field, value);
+        },
+        /**
+         * Northstar Search documents for rows of `model`. Rows read with the base
+         * client (`new PrismaClient()` without the extension, or raw SQL keyed by
+         * field name) hold stored ciphertext, which is sent with the context it is
+         * bound to and decrypted inside the enclave: indexing needs no decrypt
+         * request. Rows read through the extension hold plaintext, which is sent as is.
+         */
+        searchDocuments(model, rows, fields) {
+            if (!applied)
+                throw configError('Prisma: apply the extension (prisma.$extends(...)) before calling searchDocuments');
+            if (ambiguous)
+                throw configError('Prisma: the extension is applied to clients with different schemas; use prisma.<model>.cipherSearchDocuments(rows, fields)');
+            return searchDocs(applied, model, rows, fields);
+        },
+    });
+}
+export { CipherError };
+//# sourceMappingURL=prisma.js.map