@nexcraft-dev/r2d1 0.0.0-stage → 0.1.0

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE5D,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAElE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAmBjD,cAAc,kBAAkB,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC","sourcesContent":["export { R2D1, R2D1Collection } from './core/collection.js';\nexport type { CollectionOptions } from './core/collection.js';\nexport { CollectionSchema, defineSchema } from './core/schema.js';\nexport type { SchemaOptions, IndexedFields } from './core/schema.js';\nexport { Query } from './core/query.js';\nexport type { Comparison } from './core/query.js';\nexport { jsonCodec } from './core/codec.js';\nexport type { DocumentCodec } from './core/codec.js';\nexport { StoredDocument } from './core/model.js';\nexport type {\n  DocumentKey,\n  DocumentStore,\n  DocumentPage,\n  CollectionMetadata,\n  IndexStore,\n  IndexValue,\n  IndexType,\n  IndexEntry,\n  IndexCursor,\n  IndexPage,\n  IndexQuery,\n  Filter,\n  Sort,\n  SortDirection,\n  ComparisonOperator,\n  Page,\n} from './core/model.js';\nexport * from './core/errors.js';\nexport { encodeCursor, decodeCursor } from './core/cursor.js';\n"]}

package/dist/node/d1.d.ts

@@ -0,0 +1,10 @@
+import { D1IndexStore } from '../storage/d1.js';
+export interface NodeD1Options {
+    readonly accountId: string;
+    readonly databaseId: string;
+    readonly apiToken: string;
+    readonly fetch?: typeof globalThis.fetch;
+}
+export declare class NodeD1IndexStore extends D1IndexStore {
+    constructor(options: NodeD1Options);
+}

package/dist/node/d1.js

@@ -0,0 +1,57 @@
+import { StorageAccessError, StorageOperationError, StorageUnavailableError, } from '../core/errors.js';
+import { text } from '../core/model.js';
+import { D1IndexStore, sqlRows } from '../storage/d1.js';
+class RestD1Transport {
+    #endpoint;
+    #token;
+    #fetch;
+    constructor(options) {
+        this.#endpoint = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(text(options.accountId, 'accountId'))}/d1/database/${encodeURIComponent(text(options.databaseId, 'databaseId'))}/query`;
+        this.#token = text(options.apiToken, 'apiToken');
+        this.#fetch = options.fetch ?? globalThis.fetch;
+    }
+    async execute(statement) {
+        let response;
+        try {
+            response = await this.#fetch(this.#endpoint, {
+                method: 'POST',
+                redirect: 'error',
+                headers: { Authorization: `Bearer ${this.#token}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ sql: statement.sql, params: statement.params }),
+            });
+        }
+        catch {
+            throw new StorageUnavailableError('D1 request failed before receiving a response');
+        }
+        if (response.status === 401 || response.status === 403)
+            throw new StorageAccessError(`D1 access denied with HTTP status ${response.status}`);
+        if (response.status === 429 || response.status >= 500)
+            throw new StorageUnavailableError(`D1 unavailable with HTTP status ${response.status}`);
+        if (!response.ok)
+            throw new StorageOperationError(`D1 request failed with HTTP status ${response.status}`);
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            throw new StorageOperationError('D1 response could not be decoded');
+        }
+        if (!payload || typeof payload !== 'object')
+            throw new StorageOperationError('D1 returned an invalid response');
+        const envelope = payload;
+        if (envelope['success'] !== true ||
+            !Array.isArray(envelope['result']) ||
+            envelope['result'].length !== 1)
+            throw new StorageOperationError('D1 API reported failure or invalid result count');
+        const result = envelope['result'][0];
+        if (!result || result['success'] !== true)
+            throw new StorageOperationError('D1 query reported failure');
+        return sqlRows(result['results'] ?? []);
+    }
+}
+export class NodeD1IndexStore extends D1IndexStore {
+    constructor(options) {
+        super(new RestD1Transport(options));
+    }
+}
+//# sourceMappingURL=d1.js.map

package/dist/node/d1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"d1.js","sourceRoot":"","sources":["../../src/node/d1.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  StorageAccessError,\n  StorageOperationError,\n  StorageUnavailableError,\n} from '../core/errors.js';\nimport { text } from '../core/model.js';\nimport { D1IndexStore, sqlRows } from '../storage/d1.js';\nimport type { D1Transport, SqlResult, SqlStatement } from '../storage/d1.js';\n\nexport interface NodeD1Options {\n  readonly accountId: string;\n  readonly databaseId: string;\n  readonly apiToken: string;\n  readonly fetch?: typeof globalThis.fetch;\n}\nclass RestD1Transport implements D1Transport {\n  readonly #endpoint: string;\n  readonly #token: string;\n  readonly #fetch: typeof globalThis.fetch;\n  constructor(options: NodeD1Options) {\n    this.#endpoint = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(text(options.accountId, 'accountId'))}/d1/database/${encodeURIComponent(text(options.databaseId, 'databaseId'))}/query`;\n    this.#token = text(options.apiToken, 'apiToken');\n    this.#fetch = options.fetch ?? globalThis.fetch;\n  }\n  async execute(statement: SqlStatement): Promise<SqlResult> {\n    let response: Response;\n    try {\n      response = await this.#fetch(this.#endpoint, {\n        method: 'POST',\n        redirect: 'error',\n        headers: { Authorization: `Bearer ${this.#token}`, 'Content-Type': 'application/json' },\n        body: JSON.stringify({ sql: statement.sql, params: statement.params }),\n      });\n    } catch {\n      throw new StorageUnavailableError('D1 request failed before receiving a response');\n    }\n    if (response.status === 401 || response.status === 403)\n      throw new StorageAccessError(`D1 access denied with HTTP status ${response.status}`);\n    if (response.status === 429 || response.status >= 500)\n      throw new StorageUnavailableError(`D1 unavailable with HTTP status ${response.status}`);\n    if (!response.ok)\n      throw new StorageOperationError(`D1 request failed with HTTP status ${response.status}`);\n    let payload: unknown;\n    try {\n      payload = await response.json();\n    } catch {\n      throw new StorageOperationError('D1 response could not be decoded');\n    }\n    if (!payload || typeof payload !== 'object')\n      throw new StorageOperationError('D1 returned an invalid response');\n    const envelope = payload as Record<string, unknown>;\n    if (\n      envelope['success'] !== true ||\n      !Array.isArray(envelope['result']) ||\n      envelope['result'].length !== 1\n    )\n      throw new StorageOperationError('D1 API reported failure or invalid result count');\n    const result = envelope['result'][0] as Record<string, unknown> | null;\n    if (!result || result['success'] !== true)\n      throw new StorageOperationError('D1 query reported failure');\n    return sqlRows(result['results'] ?? []);\n  }\n}\nexport class NodeD1IndexStore extends D1IndexStore {\n  constructor(options: NodeD1Options) {\n    super(new RestD1Transport(options));\n  }\n}\n"]}

package/dist/node/index.d.ts

@@ -0,0 +1,4 @@
+export { NodeR2DocumentStore } from './r2.js';
+export type { NodeR2Options } from './r2.js';
+export { NodeD1IndexStore } from './d1.js';
+export type { NodeD1Options } from './d1.js';

package/dist/node/index.js

@@ -0,0 +1,3 @@
+export { NodeR2DocumentStore } from './r2.js';
+export { NodeD1IndexStore } from './d1.js';
+//# sourceMappingURL=index.js.map

package/dist/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/node/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC","sourcesContent":["export { NodeR2DocumentStore } from './r2.js';\nexport type { NodeR2Options } from './r2.js';\nexport { NodeD1IndexStore } from './d1.js';\nexport type { NodeD1Options } from './d1.js';\n"]}

package/dist/node/r2.d.ts

@@ -0,0 +1,23 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { StoredDocument } from '../core/model.js';
+import type { DocumentKey, DocumentPage, DocumentStore } from '../core/model.js';
+export type NodeR2Options = {
+    readonly bucket: string;
+} & ({
+    readonly client: S3Client;
+} | {
+    readonly endpoint: string;
+    readonly accessKeyId: string;
+    readonly secretAccessKey: string;
+    readonly region?: string;
+});
+export declare class NodeR2DocumentStore implements DocumentStore {
+    #private;
+    constructor(options: NodeR2Options);
+    put(documentKey: DocumentKey, document: StoredDocument): Promise<void>;
+    get(documentKey: DocumentKey): Promise<StoredDocument>;
+    delete(documentKey: DocumentKey): Promise<void>;
+    list(collection: string, cursor: string | undefined, limit: number): Promise<DocumentPage>;
+    /** Destroys only an internally created client. Borrowed clients stay open. */
+    close(): void;
+}

package/dist/node/r2.js

@@ -0,0 +1,115 @@
+import { S3Client, GetObjectCommand, PutObjectCommand, DeleteObjectCommand, ListObjectsV2Command, } from '@aws-sdk/client-s3';
+import { DocumentNotFoundError, StorageAccessError, StorageOperationError, StorageUnavailableError, } from '../core/errors.js';
+import { positive, StoredDocument, text } from '../core/model.js';
+import { collectionPrefix, documentKeyFromObject, objectKey } from '../storage/r2-key.js';
+function status(cause) {
+    if (!cause || typeof cause !== 'object')
+        return undefined;
+    return cause.$metadata?.httpStatusCode;
+}
+function missing(cause) {
+    return status(cause) === 404 || (cause instanceof Error && cause.name === 'NoSuchKey');
+}
+function failure(cause) {
+    const code = status(cause);
+    if (code === 401 || code === 403)
+        return new StorageAccessError('R2 access denied');
+    if (code === 429 || (code !== undefined && code >= 500))
+        return new StorageUnavailableError('R2 is unavailable');
+    return new StorageOperationError('R2 operation failed');
+}
+export class NodeR2DocumentStore {
+    #client;
+    #bucket;
+    #ownsClient;
+    #closed = false;
+    constructor(options) {
+        this.#bucket = text(options.bucket, 'bucket');
+        this.#ownsClient = !('client' in options);
+        if ('client' in options)
+            this.#client = options.client;
+        else {
+            const endpoint = new URL(options.endpoint);
+            if (endpoint.protocol !== 'https:' ||
+                endpoint.username ||
+                endpoint.password ||
+                endpoint.search ||
+                endpoint.hash)
+                throw new TypeError('R2 endpoint must be an HTTPS URL without credentials, query or fragment');
+            this.#client = new S3Client({
+                endpoint: endpoint.href,
+                region: options.region ?? 'auto',
+                forcePathStyle: true,
+                credentials: {
+                    accessKeyId: text(options.accessKeyId, 'accessKeyId'),
+                    secretAccessKey: text(options.secretAccessKey, 'secretAccessKey'),
+                },
+                maxAttempts: 1,
+                requestChecksumCalculation: 'WHEN_REQUIRED',
+                responseChecksumValidation: 'WHEN_REQUIRED',
+            });
+        }
+    }
+    async put(documentKey, document) {
+        const input = { Bucket: this.#bucket, Key: objectKey(documentKey), Body: document.content() };
+        try {
+            await this.#client.send(new PutObjectCommand(input));
+        }
+        catch (cause) {
+            throw failure(cause);
+        }
+    }
+    async get(documentKey) {
+        const input = { Bucket: this.#bucket, Key: objectKey(documentKey) };
+        try {
+            const result = await this.#client.send(new GetObjectCommand(input));
+            if (!result.Body)
+                throw new StorageOperationError('R2 get returned no body');
+            return new StoredDocument(await result.Body.transformToByteArray());
+        }
+        catch (cause) {
+            if (missing(cause))
+                throw new DocumentNotFoundError(documentKey);
+            throw failure(cause);
+        }
+    }
+    async delete(documentKey) {
+        const input = { Bucket: this.#bucket, Key: objectKey(documentKey) };
+        try {
+            await this.#client.send(new DeleteObjectCommand(input));
+        }
+        catch (cause) {
+            if (!missing(cause))
+                throw failure(cause);
+        }
+    }
+    async list(collection, cursor, limit) {
+        const input = {
+            Bucket: this.#bucket,
+            Prefix: collectionPrefix(collection),
+            MaxKeys: positive(limit, 'limit'),
+            ...(cursor !== undefined ? { ContinuationToken: text(cursor, 'cursor') } : {}),
+        };
+        try {
+            const result = await this.#client.send(new ListObjectsV2Command(input));
+            const documentKeys = (result.Contents ?? []).map((item) => documentKeyFromObject(collection, item.Key ?? ''));
+            if (documentKeys.length > limit)
+                throw new StorageOperationError('R2 listing exceeded page limit');
+            const nextCursor = result.NextContinuationToken;
+            if (result.IsTruncated && !nextCursor)
+                throw new StorageOperationError('R2 listing is truncated without a cursor');
+            return { documentKeys, ...(nextCursor ? { nextCursor } : {}) };
+        }
+        catch (cause) {
+            throw failure(cause);
+        }
+    }
+    /** Destroys only an internally created client. Borrowed clients stay open. */
+    close() {
+        if (this.#ownsClient && !this.#closed) {
+            this.#closed = true;
+            this.#client.destroy();
+        }
+    }
+}
+//# sourceMappingURL=r2.js.map

package/dist/node/r2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"r2.js","sourceRoot":"","sources":["../../src/node/r2.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  S3Client,\n  GetObjectCommand,\n  PutObjectCommand,\n  DeleteObjectCommand,\n  ListObjectsV2Command,\n} from '@aws-sdk/client-s3';\nimport {\n  DocumentNotFoundError,\n  StorageAccessError,\n  StorageOperationError,\n  StorageUnavailableError,\n} from '../core/errors.js';\nimport { positive, StoredDocument, text } from '../core/model.js';\nimport type { DocumentKey, DocumentPage, DocumentStore } from '../core/model.js';\nimport { collectionPrefix, documentKeyFromObject, objectKey } from '../storage/r2-key.js';\n\nexport type NodeR2Options = { readonly bucket: string } & (\n  | { readonly client: S3Client }\n  | {\n      readonly endpoint: string;\n      readonly accessKeyId: string;\n      readonly secretAccessKey: string;\n      readonly region?: string;\n    }\n);\nfunction status(cause: unknown): number | undefined {\n  if (!cause || typeof cause !== 'object') return undefined;\n  return (cause as { $metadata?: { httpStatusCode?: number } }).$metadata?.httpStatusCode;\n}\nfunction missing(cause: unknown): boolean {\n  return status(cause) === 404 || (cause instanceof Error && cause.name === 'NoSuchKey');\n}\nfunction failure(cause: unknown): Error {\n  const code = status(cause);\n  if (code === 401 || code === 403) return new StorageAccessError('R2 access denied');\n  if (code === 429 || (code !== undefined && code >= 500))\n    return new StorageUnavailableError('R2 is unavailable');\n  return new StorageOperationError('R2 operation failed');\n}\nexport class NodeR2DocumentStore implements DocumentStore {\n  readonly #client: S3Client;\n  readonly #bucket: string;\n  readonly #ownsClient: boolean;\n  #closed = false;\n  constructor(options: NodeR2Options) {\n    this.#bucket = text(options.bucket, 'bucket');\n    this.#ownsClient = !('client' in options);\n    if ('client' in options) this.#client = options.client;\n    else {\n      const endpoint = new URL(options.endpoint);\n      if (\n        endpoint.protocol !== 'https:' ||\n        endpoint.username ||\n        endpoint.password ||\n        endpoint.search ||\n        endpoint.hash\n      )\n        throw new TypeError(\n          'R2 endpoint must be an HTTPS URL without credentials, query or fragment',\n        );\n      this.#client = new S3Client({\n        endpoint: endpoint.href,\n        region: options.region ?? 'auto',\n        forcePathStyle: true,\n        credentials: {\n          accessKeyId: text(options.accessKeyId, 'accessKeyId'),\n          secretAccessKey: text(options.secretAccessKey, 'secretAccessKey'),\n        },\n        maxAttempts: 1,\n        requestChecksumCalculation: 'WHEN_REQUIRED',\n        responseChecksumValidation: 'WHEN_REQUIRED',\n      });\n    }\n  }\n  async put(documentKey: DocumentKey, document: StoredDocument): Promise<void> {\n    const input = { Bucket: this.#bucket, Key: objectKey(documentKey), Body: document.content() };\n    try {\n      await this.#client.send(new PutObjectCommand(input));\n    } catch (cause) {\n      throw failure(cause);\n    }\n  }\n  async get(documentKey: DocumentKey): Promise<StoredDocument> {\n    const input = { Bucket: this.#bucket, Key: objectKey(documentKey) };\n    try {\n      const result = await this.#client.send(new GetObjectCommand(input));\n      if (!result.Body) throw new StorageOperationError('R2 get returned no body');\n      return new StoredDocument(await result.Body.transformToByteArray());\n    } catch (cause) {\n      if (missing(cause)) throw new DocumentNotFoundError(documentKey);\n      throw failure(cause);\n    }\n  }\n  async delete(documentKey: DocumentKey): Promise<void> {\n    const input = { Bucket: this.#bucket, Key: objectKey(documentKey) };\n    try {\n      await this.#client.send(new DeleteObjectCommand(input));\n    } catch (cause) {\n      if (!missing(cause)) throw failure(cause);\n    }\n  }\n  async list(collection: string, cursor: string | undefined, limit: number): Promise<DocumentPage> {\n    const input = {\n      Bucket: this.#bucket,\n      Prefix: collectionPrefix(collection),\n      MaxKeys: positive(limit, 'limit'),\n      ...(cursor !== undefined ? { ContinuationToken: text(cursor, 'cursor') } : {}),\n    };\n    try {\n      const result = await this.#client.send(new ListObjectsV2Command(input));\n      const documentKeys = (result.Contents ?? []).map((item) =>\n        documentKeyFromObject(collection, item.Key ?? ''),\n      );\n      if (documentKeys.length > limit)\n        throw new StorageOperationError('R2 listing exceeded page limit');\n      const nextCursor = result.NextContinuationToken;\n      if (result.IsTruncated && !nextCursor)\n        throw new StorageOperationError('R2 listing is truncated without a cursor');\n      return { documentKeys, ...(nextCursor ? { nextCursor } : {}) };\n    } catch (cause) {\n      throw failure(cause);\n    }\n  }\n  /** Destroys only an internally created client. Borrowed clients stay open. */\n  close(): void {\n    if (this.#ownsClient && !this.#closed) {\n      this.#closed = true;\n      this.#client.destroy();\n    }\n  }\n}\n"]}

package/dist/storage/d1.d.ts

@@ -0,0 +1,28 @@
+import type { CollectionMetadata, DocumentKey, IndexEntry, IndexQuery, IndexStore, IndexPage } from '../core/model.js';
+export interface SqlStatement {
+    readonly sql: string;
+    readonly params: readonly (string | number)[];
+}
+export interface SqlResult {
+    readonly rows: readonly Readonly<Record<string, unknown>>[];
+}
+export interface D1Transport {
+    execute(statement: SqlStatement): Promise<SqlResult>;
+}
+export declare function compileUpsert(metadata: CollectionMetadata, entry: IndexEntry): SqlStatement;
+export declare function compileQuery(metadata: CollectionMetadata, query: IndexQuery): SqlStatement;
+export declare function queryPage(metadata: CollectionMetadata, query: IndexQuery, result: SqlResult): IndexPage;
+/** Shared D1 engine. Transports supply only prepared SQL execution. */
+export declare class D1IndexStore implements IndexStore {
+    #private;
+    private readonly transport;
+    constructor(transport: D1Transport);
+    initialize(input: CollectionMetadata): Promise<void>;
+    upsert(entry: IndexEntry): Promise<void>;
+    query(query: IndexQuery): Promise<IndexPage>;
+    delete(documentKey: DocumentKey): Promise<void>;
+    clear(collection: string): Promise<void>;
+    private registration;
+}
+/** Validate transport rows without accepting arrays, nulls, or primitive values. */
+export declare function sqlRows(value: unknown): SqlResult;

package/dist/storage/d1.js

@@ -0,0 +1,301 @@
+import { StorageOperationError } from '../core/errors.js';
+import { indexValue, key, positive } from '../core/model.js';
+import { identifier, validateMetadata } from '../core/schema.js';
+const quote = (name) => `"${identifier(name)}"`;
+const sqlTypes = {
+    string: 'TEXT',
+    long: 'INTEGER',
+    double: 'REAL',
+    boolean: 'INTEGER',
+};
+const defaults = {
+    string: "''",
+    long: '0',
+    double: '0.0',
+    boolean: '0',
+};
+function fieldType(metadata, name) {
+    const field = metadata.fields.find((f) => f.name === name);
+    if (!field)
+        throw new TypeError(`field is not indexed: ${name}`);
+    return field.type;
+}
+function compatible(type, value) {
+    if (!value || value.type !== type)
+        throw new TypeError(`index value type does not match ${type}`);
+    return indexValue(type, value.value);
+}
+function parameter(params, value) {
+    if (value.type === 'timestamp')
+        throw new TypeError('D1 does not support timestamp indexes');
+    params.push(value.type === 'long'
+        ? value.value.toString()
+        : value.type === 'boolean'
+            ? Number(value.value)
+            : value.value);
+    const placeholder = `?${params.length}`;
+    return value.type === 'long' ? `CAST(${placeholder} AS INTEGER)` : placeholder;
+}
+function sameCollection(metadata, collection) {
+    if (metadata.collection !== collection)
+        throw new TypeError('collection does not match initialized metadata');
+}
+export function compileUpsert(metadata, entry) {
+    sameCollection(metadata, entry.documentKey.collection);
+    key(entry.documentKey.collection, entry.documentKey.id);
+    for (const field of Object.keys(entry.values))
+        fieldType(metadata, field);
+    const params = [entry.documentKey.id];
+    const columns = ['"document_id"', ...metadata.fields.map((f) => quote(f.name))];
+    const placeholders = [
+        '?1',
+        ...metadata.fields.map((f) => parameter(params, compatible(f.type, entry.values[f.name]))),
+    ];
+    const conflict = metadata.fields.length
+        ? 'DO UPDATE SET ' +
+            metadata.fields.map((f) => `${quote(f.name)} = excluded.${quote(f.name)}`).join(', ')
+        : 'DO NOTHING';
+    return {
+        sql: `INSERT INTO ${quote(metadata.collection)} (${columns.join(', ')}) VALUES (${placeholders.join(', ')}) ON CONFLICT("document_id") ${conflict}`,
+        params,
+    };
+}
+export function compileQuery(metadata, query) {
+    sameCollection(metadata, query.collection);
+    positive(query.limit, 'limit');
+    const params = [];
+    const conditions = query.filters.map((filter) => {
+        const type = fieldType(metadata, filter.field);
+        if (!['=', '<>', '>', '>=', '<', '<='].includes(filter.operator))
+            throw new TypeError('unsupported comparison');
+        if (type === 'boolean' && filter.operator !== '=' && filter.operator !== '<>')
+            throw new TypeError('boolean supports only equality comparisons');
+        return `${quote(filter.field)} ${filter.operator} ${parameter(params, compatible(type, filter.value))}`;
+    });
+    const sort = query.sort;
+    let sortType;
+    if (sort) {
+        sortType = fieldType(metadata, sort.field);
+        if (sort.direction !== 'ASC' && sort.direction !== 'DESC')
+            throw new TypeError('invalid sort direction');
+    }
+    const direction = sort?.direction ?? 'ASC';
+    if (query.cursor) {
+        const cursor = query.cursor;
+        sameCollection(metadata, cursor.lastDocumentKey.collection);
+        key(cursor.lastDocumentKey.collection, cursor.lastDocumentKey.id);
+        if (!sort) {
+            if (cursor.sortValue !== undefined)
+                throw new TypeError('unsorted cursor must not include sort value');
+            conditions.push(`"document_id" > ${parameter(params, { type: 'string', value: cursor.lastDocumentKey.id })}`);
+        }
+        else {
+            const value = parameter(params, compatible(sortType, cursor.sortValue));
+            const id = parameter(params, { type: 'string', value: cursor.lastDocumentKey.id });
+            const op = direction === 'ASC' ? '>' : '<';
+            conditions.push(`(${quote(sort.field)} ${op} ${value} OR (${quote(sort.field)} = ${value} AND "document_id" ${op} ${id}))`);
+        }
+    }
+    const projection = sort
+        ? ', ' +
+            (sortType === 'long'
+                ? `CAST(${quote(sort.field)} AS TEXT) AS ${quote(sort.field)}`
+                : quote(sort.field))
+        : '';
+    const order = sort
+        ? `${quote(metadata.collection)}.${quote(sort.field)} ${direction}, "document_id" ${direction}`
+        : '"document_id" ASC';
+    params.push(query.limit + 1);
+    return {
+        sql: `SELECT "document_id"${projection} FROM ${quote(metadata.collection)}${conditions.length ? ' WHERE ' + conditions.join(' AND ') : ''} ORDER BY ${order} LIMIT ?${params.length}`,
+        params,
+    };
+}
+function readValue(type, value) {
+    try {
+        if (type === 'long') {
+            if (typeof value !== 'string' || !/^-?\d+$/.test(value))
+                throw new TypeError();
+            return indexValue(type, BigInt(value));
+        }
+        if (type === 'boolean') {
+            if (value !== 0 && value !== 1)
+                throw new TypeError();
+            return indexValue(type, value === 1);
+        }
+        return indexValue(type, value);
+    }
+    catch {
+        throw new StorageOperationError('D1 returned an invalid indexed value');
+    }
+}
+export function queryPage(metadata, query, result) {
+    const rows = result.rows.slice(0, query.limit);
+    const keys = rows.map((row) => {
+        try {
+            return key(metadata.collection, row['document_id']);
+        }
+        catch {
+            throw new StorageOperationError('D1 returned an invalid document_id');
+        }
+    });
+    // Validate each returned sort value, including final pages.
+    const sortValues = query.sort
+        ? rows.map((row) => readValue(fieldType(metadata, query.sort.field), row[query.sort.field]))
+        : [];
+    const hasMore = result.rows.length > query.limit && keys.length > 0;
+    return {
+        documentKeys: keys,
+        ...(hasMore
+            ? {
+                nextCursor: {
+                    lastDocumentKey: keys.at(-1),
+                    ...(query.sort ? { sortValue: sortValues.at(-1) } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function stringCell(row, name) {
+    const value = row[name];
+    if (typeof value !== 'string')
+        throw new StorageOperationError(`D1 schema returned invalid ${name}`);
+    return value;
+}
+function integerCell(row, name) {
+    const value = row[name];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value))
+        throw new StorageOperationError(`D1 schema returned invalid ${name}`);
+    return value;
+}
+async function initializeSchema(transport, metadata) {
+    const table = quote(metadata.collection);
+    const execute = (sql) => transport.execute({ sql, params: [] });
+    const inspect = async () => {
+        const result = await execute(`PRAGMA table_info(${table})`);
+        const columns = new Map();
+        for (const row of result.rows) {
+            const name = stringCell(row, 'name');
+            if (columns.has(name))
+                throw new StorageOperationError('D1 returned duplicate columns');
+            columns.set(name, row);
+        }
+        return columns;
+    };
+    const validate = (columns, requireAll) => {
+        const id = columns.get('document_id');
+        if (!id ||
+            stringCell(id, 'type').toUpperCase() !== 'TEXT' ||
+            integerCell(id, 'notnull') !== 1 ||
+            integerCell(id, 'pk') <= 0)
+            throw new StorageOperationError('D1 schema has incompatible document_id');
+        for (const field of metadata.fields) {
+            const actual = columns.get(field.name);
+            if (!actual && !requireAll)
+                continue;
+            if (!actual ||
+                stringCell(actual, 'type').toUpperCase() !== sqlTypes[field.type] ||
+                integerCell(actual, 'notnull') !== 1 ||
+                integerCell(actual, 'pk') !== 0)
+                throw new StorageOperationError(`D1 schema has incompatible column: ${field.name}`);
+        }
+    };
+    let columns = await inspect();
+    if (columns.size === 0) {
+        const definitions = [
+            '"document_id" TEXT PRIMARY KEY NOT NULL',
+            ...metadata.fields.map((f) => `${quote(f.name)} ${sqlTypes[f.type]} NOT NULL`),
+        ];
+        await execute(`CREATE TABLE IF NOT EXISTS ${table} (${definitions.join(', ')})`);
+        columns = await inspect();
+        validate(columns, true);
+    }
+    else {
+        validate(columns, false);
+        const missing = metadata.fields.filter((f) => !columns.has(f.name));
+        if (missing.length) {
+            const result = await execute(`SELECT EXISTS(SELECT 1 FROM ${table} LIMIT 1) AS "has_rows"`);
+            if (result.rows.length !== 1)
+                throw new StorageOperationError('D1 row-existence query returned invalid result');
+            const exists = integerCell(result.rows[0], 'has_rows');
+            if (exists !== 0 && exists !== 1)
+                throw new StorageOperationError('D1 row-existence query returned invalid value');
+            if (exists)
+                throw new StorageOperationError('D1 schema requires a rebuild before adding required indexed fields');
+            for (const field of missing)
+                await execute(`ALTER TABLE ${table} ADD COLUMN ${quote(field.name)} ${sqlTypes[field.type]} NOT NULL DEFAULT ${defaults[field.type]}`);
+            validate(await inspect(), true);
+        }
+    }
+    for (const field of metadata.fields) {
+        const name = `idx_${metadata.collection}_${field.name}`;
+        const inspectNames = async () => (await execute(`PRAGMA index_list(${table})`)).rows.map((r) => stringCell(r, 'name'));
+        if (!(await inspectNames()).includes(name))
+            await execute(`CREATE INDEX IF NOT EXISTS ${quote(name)} ON ${table} (${quote(field.name)})`);
+        if (!(await inspectNames()).includes(name))
+            throw new StorageOperationError('D1 index name is unavailable');
+        const info = await execute(`PRAGMA index_info(${quote(name)})`);
+        if (info.rows.length !== 1 || stringCell(info.rows[0], 'name') !== field.name)
+            throw new StorageOperationError('D1 index is incompatible with indexed field');
+    }
+}
+/** Shared D1 engine. Transports supply only prepared SQL execution. */
+export class D1IndexStore {
+    transport;
+    #registrations = new Map();
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async initialize(input) {
+        const metadata = validateMetadata(input);
+        const existing = this.#registrations.get(metadata.collection);
+        if (existing) {
+            if (JSON.stringify(existing.metadata) !== JSON.stringify(metadata))
+                throw new TypeError('collection is already initialized with different metadata');
+            return existing.ready;
+        }
+        const ready = Promise.resolve().then(() => initializeSchema(this.transport, metadata));
+        this.#registrations.set(metadata.collection, { metadata, ready });
+        return ready;
+    }
+    async upsert(entry) {
+        const registration = this.registration(entry.documentKey.collection);
+        const statement = compileUpsert(registration.metadata, entry);
+        await registration.ready;
+        await this.transport.execute(statement);
+    }
+    async query(query) {
+        const registration = this.registration(query.collection);
+        const statement = compileQuery(registration.metadata, query);
+        await registration.ready;
+        return queryPage(registration.metadata, query, await this.transport.execute(statement));
+    }
+    async delete(documentKey) {
+        key(documentKey.collection, documentKey.id);
+        const registration = this.registration(documentKey.collection);
+        await registration.ready;
+        await this.transport.execute({
+            sql: `DELETE FROM ${quote(documentKey.collection)} WHERE "document_id" = ?1`,
+            params: [documentKey.id],
+        });
+    }
+    async clear(collection) {
+        const registration = this.registration(collection);
+        await registration.ready;
+        await this.transport.execute({ sql: `DELETE FROM ${quote(collection)}`, params: [] });
+    }
+    registration(collection) {
+        const registration = this.#registrations.get(collection);
+        if (!registration)
+            throw new StorageOperationError('D1 collection is not initialized');
+        return registration;
+    }
+}
+/** Validate transport rows without accepting arrays, nulls, or primitive values. */
+export function sqlRows(value) {
+    if (!Array.isArray(value) ||
+        value.some((row) => row === null || typeof row !== 'object' || Array.isArray(row)))
+        throw new StorageOperationError('D1 returned invalid rows');
+    return { rows: value };
+}
+//# sourceMappingURL=d1.js.map