ts-prorm-orm 1.1.0

package/dist/models/operators.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Operator symbols for the ORM
+ * Provides all Prorm operators for query building
+ * This file re-exports from the main operators.ts for consistency
+ *
+ * Usage Examples:
+ * ```typescript
+ * import { Op, and, or, eq, gte } from 'orm';
+ *
+ * // Using Op directly (recommended)
+ * User.findAll({ where: { age: { [Op.gte]: 18 } } })
+ * User.findAll({ where: { name: { [Op.like]: '%john%' } } })
+ *
+ * // Using helper functions
+ * User.findAll({ where: and({ name: 'John' }, { age: gte('age', 18) }) })
+ *
+ * // Column comparison
+ * User.findAll({ where: { balance: { [Op.eq]: Op.col('credit_limit') } } })
+ *
+ * // JSON column queries
+ * User.findAll({ where: { settings: Op.json({ theme: 'dark' }) } })
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.Op = exports.isOrderExpression = exports.random = exports.desc = exports.asc = exports.Cast = exports.cast = exports.overlap = exports.contains = exports.notIRegexp = exports.iRegexp = exports.notRegexp = exports.regexp = exports.notILike = exports.iLike = exports.isOperator = exports.operatorToWhereKey = exports.where = exports.isNotNull = exports.isNull = exports.notBetween = exports.between = exports.notIn = exports.in = exports.notLike = exports.like = exports.lte = exports.lt = exports.gte = exports.gt = exports.ne = exports.eq = exports.not = exports.or = exports.and = void 0;
+// Re-export helper functions from main operators.ts
+var operators_1 = require("../operators");
+Object.defineProperty(exports, "and", { enumerable: true, get: function () { return operators_1.and; } });
+Object.defineProperty(exports, "or", { enumerable: true, get: function () { return operators_1.or; } });
+Object.defineProperty(exports, "not", { enumerable: true, get: function () { return operators_1.not; } });
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return operators_1.eq; } });
+Object.defineProperty(exports, "ne", { enumerable: true, get: function () { return operators_1.ne; } });
+Object.defineProperty(exports, "gt", { enumerable: true, get: function () { return operators_1.gt; } });
+Object.defineProperty(exports, "gte", { enumerable: true, get: function () { return operators_1.gte; } });
+Object.defineProperty(exports, "lt", { enumerable: true, get: function () { return operators_1.lt; } });
+Object.defineProperty(exports, "lte", { enumerable: true, get: function () { return operators_1.lte; } });
+Object.defineProperty(exports, "like", { enumerable: true, get: function () { return operators_1.like; } });
+Object.defineProperty(exports, "notLike", { enumerable: true, get: function () { return operators_1.notLike; } });
+Object.defineProperty(exports, "in", { enumerable: true, get: function () { return operators_1.inOp; } });
+Object.defineProperty(exports, "notIn", { enumerable: true, get: function () { return operators_1.notIn; } });
+Object.defineProperty(exports, "between", { enumerable: true, get: function () { return operators_1.between; } });
+Object.defineProperty(exports, "notBetween", { enumerable: true, get: function () { return operators_1.notBetween; } });
+Object.defineProperty(exports, "isNull", { enumerable: true, get: function () { return operators_1.isNull; } });
+Object.defineProperty(exports, "isNotNull", { enumerable: true, get: function () { return operators_1.isNotNull; } });
+Object.defineProperty(exports, "where", { enumerable: true, get: function () { return operators_1.where; } });
+Object.defineProperty(exports, "operatorToWhereKey", { enumerable: true, get: function () { return operators_1.operatorToWhereKey; } });
+Object.defineProperty(exports, "isOperator", { enumerable: true, get: function () { return operators_1.isOperator; } });
+Object.defineProperty(exports, "iLike", { enumerable: true, get: function () { return operators_1.iLike; } });
+Object.defineProperty(exports, "notILike", { enumerable: true, get: function () { return operators_1.notILike; } });
+Object.defineProperty(exports, "regexp", { enumerable: true, get: function () { return operators_1.regexp; } });
+Object.defineProperty(exports, "notRegexp", { enumerable: true, get: function () { return operators_1.notRegexp; } });
+Object.defineProperty(exports, "iRegexp", { enumerable: true, get: function () { return operators_1.iRegexp; } });
+Object.defineProperty(exports, "notIRegexp", { enumerable: true, get: function () { return operators_1.notIRegexp; } });
+Object.defineProperty(exports, "contains", { enumerable: true, get: function () { return operators_1.contains; } });
+Object.defineProperty(exports, "overlap", { enumerable: true, get: function () { return operators_1.overlap; } });
+Object.defineProperty(exports, "cast", { enumerable: true, get: function () { return operators_1.cast; } });
+Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return operators_1.Cast; } });
+// Order helpers
+Object.defineProperty(exports, "asc", { enumerable: true, get: function () { return operators_1.asc; } });
+Object.defineProperty(exports, "desc", { enumerable: true, get: function () { return operators_1.desc; } });
+Object.defineProperty(exports, "random", { enumerable: true, get: function () { return operators_1.random; } });
+Object.defineProperty(exports, "isOrderExpression", { enumerable: true, get: function () { return operators_1.isOrderExpression; } });
+// Import Op and re-export it (needed for default export)
+const operators_2 = require("../operators");
+Object.defineProperty(exports, "Op", { enumerable: true, get: function () { return operators_2.Op; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return operators_2.Op; } });

package/dist/models/scopes.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Scope management for the ORM
+ * Provides defaultScope, named scopes, and scoped model access
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeManager = void 0;
+/**
+ * Scope manager for model scoping
+ */
+class ScopeManager {
+    constructor(model) {
+        this.scopes = new Map();
+        this.defaultScope = null;
+        this._currentScope = null;
+        this.model = model;
+    }
+    /**
+     * Add a named scope
+     */
+    addScope(name, options) {
+        this.scopes.set(name, options);
+    }
+    /**
+     * Set the default scope
+     */
+    setDefaultScope(options) {
+        this.defaultScope = options;
+    }
+    /**
+     * Get a scope by name
+     */
+    getScope(name) {
+        return this.scopes.get(name);
+    }
+    /**
+     * Check if a scope exists
+     */
+    hasScope(name) {
+        return this.scopes.has(name);
+    }
+    /**
+     * Remove a scope by name
+     */
+    removeScope(name) {
+        if (!this.scopes.has(name)) {
+            return false;
+        }
+        this.scopes.delete(name);
+        return true;
+    }
+    /**
+     * Clear all named scopes
+     */
+    clearScopes() {
+        this.scopes.clear();
+    }
+    /**
+     * Get the count of defined scopes
+     */
+    getScopeCount() {
+        return this.scopes.size;
+    }
+    /**
+     * Get all defined scopes
+     */
+    getAllScopes() {
+        return new Map(this.scopes);
+    }
+    /**
+     * Get the default scope
+     */
+    getDefaultScope() {
+        return this.defaultScope;
+    }
+    /**
+     * Apply a scope to options
+     */
+    applyScope(scopeName, options = {}) {
+        const scope = this.scopes.get(scopeName);
+        if (!scope) {
+            throw new Error(`Scope '${scopeName}' not found`);
+        }
+        this._currentScope = scopeName;
+        // Merge scope options with provided options
+        return this.mergeScopeOptions(options, scope);
+    }
+    /**
+     * Get the current active scope name
+     */
+    getCurrentScope() {
+        return this._currentScope;
+    }
+    /**
+     * Clear the current scope
+     */
+    clearScope() {
+        this._currentScope = null;
+    }
+    /**
+     * Merge scope options with query options
+     */
+    mergeScopeOptions(options, scope) {
+        const merged = { ...options };
+        // Merge attributes
+        if (scope.attributes) {
+            merged.attributes = scope.attributes;
+        }
+        // Merge where conditions
+        if (scope.where) {
+            if (merged.where) {
+                merged.where = this.mergeWhere(merged.where, scope.where);
+            }
+            else {
+                merged.where = scope.where;
+            }
+        }
+        // Merge include
+        if (scope.include) {
+            if (merged.include) {
+                merged.include = [...merged.include, ...scope.include];
+            }
+            else {
+                merged.include = scope.include;
+            }
+        }
+        // Merge order
+        if (scope.order) {
+            if (merged.order) {
+                const mergedOrder = Array.isArray(merged.order) ? merged.order : [merged.order];
+                const scopeOrder = Array.isArray(scope.order) ? scope.order : [scope.order];
+                merged.order = [...mergedOrder, ...scopeOrder];
+            }
+            else {
+                merged.order = scope.order;
+            }
+        }
+        // Merge limit (only if not already set)
+        if (scope.limit !== undefined && merged.limit === undefined) {
+            merged.limit = scope.limit;
+        }
+        // Merge offset (only if not already set)
+        if (scope.offset !== undefined && merged.offset === undefined) {
+            merged.offset = scope.offset;
+        }
+        return merged;
+    }
+    /**
+     * Merge where conditions
+     */
+    mergeWhere(a, b) {
+        const aObj = a;
+        const bObj = b;
+        const aKeys = Object.keys(aObj);
+        const bKeys = Object.keys(bObj);
+        // Detect whether the two where clauses interact in a way that a shallow
+        // spread would silently drop constraints: either they share a field key
+        // (b would clobber a), or either side uses a logical operator whose value
+        // is an array/nested clause that a spread cannot combine.
+        const logicalKeys = ['$and', '$or', '$not'];
+        const hasSharedKey = bKeys.some((k) => aKeys.includes(k));
+        const hasLogical = aKeys.some((k) => logicalKeys.includes(k)) ||
+            bKeys.some((k) => logicalKeys.includes(k));
+        // Backward-compatible fast path: no overlap and no logical operators, so a
+        // shallow merge is equivalent to ANDing both sets of constraints.
+        if (!hasSharedKey && !hasLogical) {
+            return { ...aObj, ...bObj };
+        }
+        // Otherwise combine both clauses under $and so the caller's constraints and
+        // the scope's constraints both apply. Flatten an existing top-level $and on
+        // either side to avoid needless nesting.
+        const combine = [];
+        const flatten = (where) => {
+            const keys = Object.keys(where);
+            if (keys.length === 1 && keys[0] === '$and' && Array.isArray(where.$and)) {
+                for (const clause of where.$and) {
+                    combine.push(clause);
+                }
+            }
+            else {
+                combine.push(where);
+            }
+        };
+        flatten(aObj);
+        flatten(bObj);
+        return { $and: combine };
+    }
+}
+exports.ScopeManager = ScopeManager;

package/dist/models/typescript-types.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * TypeScript Type Utilities for Model Definitions
+ *
+ * This module provides TypeScript type utilities:
+ * - InferAttributes<T>: Extracts attribute types from a Model
+ * - InferCreationAttributes<T>: Extracts creation attributes (with optional ID, etc.)
+ * - CreationOptional<T>: Marks an attribute as optional during creation
+ * - NonAttribute<T>: Excludes non-database fields (methods, getters)
+ * - ForeignKey<T, TModel>: Branded type for foreign key relationships
+ *
+ * @example
+ * ```typescript
+ * import { Model, InferAttributes, InferCreationAttributes, CreationOptional } from 'orm';
+ *
+ * export class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
+ *   declare id: CreationOptional<number>;
+ *   declare name: string;
+ *   declare email: string;
+ *
+ *   // Non-database property
+ *   declare getFullName(): NonAttribute<string>;
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nosql/aerospike/index.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AerospikeStore = void 0;
+/**
+ * Aerospike store.
+ *
+ * Aerospike is a distributed, flash-optimized key-value store. Records are
+ * addressed by a `(namespace, set, key)` tuple and hold a flat map of named
+ * "bins" (Aerospike's term for columns/fields). It has no query language and
+ * no SQL-shaped surface (no `query(sql)`, identifier escaping, or DDL), so it
+ * does not fit the `Dialect` interface used by the SQL dialects in this repo.
+ * Instead it implements the minimal `NoSqlStore` marker interface
+ * (`src/nosql/store.ts`) and exposes Aerospike's real record primitives —
+ * `put`/`get`/`remove`/`exists`/`operate` addressed by key — directly.
+ *
+ * Built on the official `aerospike` npm driver. That driver is an optional
+ * peer dependency loaded lazily inside `connect()` (via `require`) so importing
+ * this module never forces the driver to be installed; tests inject a pre-built
+ * mock `client` instead and never reach the `require`.
+ */
+const errors_1 = require("../../errors");
+/**
+ * `AerospikeStore` wraps an `aerospike` client and exposes Aerospike's record
+ * surface: `put`/`get`/`remove`/`exists` for single-record operations,
+ * `operate` for atomic multi-op transactions on a record, and `truncate` for
+ * clearing a set. Records are addressed by a `(namespace, set, key)` tuple,
+ * built by `makeKey()`.
+ */
+class AerospikeStore {
+    constructor(options = {}) {
+        this.name = 'aerospike';
+        this.library = 'aerospike';
+        this.client = null;
+        this.connected = false;
+        /**
+         * The required `aerospike` module, kept so `makeKey()` can build a real
+         * `Aerospike.Key`. Stays `null` when a client is injected (tests), in which
+         * case `makeKey()` returns a plain `{ ns, set, key }` tuple instead.
+         */
+        this.aerospike = null;
+        this.options = options;
+        this.namespace = options.namespace ?? '';
+        this.set = options.set ?? '';
+    }
+    // ---------------------------------------------------------------------
+    // NoSqlStore lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            if (this.options.client) {
+                // Injected mock: use it directly and never touch the real driver.
+                this.client = this.options.client;
+            }
+            else {
+                // Lazy-load the optional driver so importing this module never
+                // requires `aerospike` to be installed.
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const Aerospike = require('aerospike');
+                this.aerospike = Aerospike;
+                this.client = (await Aerospike.connect({
+                    hosts: this.options.hosts,
+                    ...this.options.config,
+                }));
+            }
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.aerospike = null;
+            this.connected = false;
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw new errors_1.ConnectionError(`Unable to connect to Aerospike: ${parent.message}`, {
+                parent,
+                database: 'aerospike',
+                host: this.options.hosts?.[0]?.addr,
+            });
+        }
+    }
+    async disconnect() {
+        if (this.client) {
+            this.client.close(false);
+            this.client = null;
+        }
+        this.aerospike = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `aerospike` client for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client || !this.connected) {
+            throw new errors_1.ConnectionError('Aerospike client is not connected. Call connect() first.', {
+                database: 'aerospike',
+            });
+        }
+        return this.client;
+    }
+    wrapError(action, err) {
+        const parent = err instanceof Error ? err : new Error(String(err));
+        return errors_1.DatabaseError.from(parent, { message: `Aerospike ${action} failed: ${parent.message}` });
+    }
+    /**
+     * Builds the key object the driver expects from a `(namespace, set, key)`
+     * tuple, filling in the store's default namespace/set for anything the
+     * caller omits. When the real driver is loaded this returns a
+     * `new Aerospike.Key(namespace, set, key)`; when a mock client is injected
+     * (no module) it returns a plain `{ ns, set, key }` tuple.
+     */
+    makeKey(input) {
+        const ns = typeof input === 'object' ? input.namespace ?? this.namespace : this.namespace;
+        const set = typeof input === 'object' ? input.set ?? this.set : this.set;
+        const key = typeof input === 'object' ? input.key : input;
+        if (this.aerospike && this.aerospike.Key) {
+            return new this.aerospike.Key(ns, set, key);
+        }
+        return { ns, set, key };
+    }
+    // ---------------------------------------------------------------------
+    // Record operations
+    // ---------------------------------------------------------------------
+    /** Writes (puts) a record's bins. Optionally accepts write metadata (TTL/generation). */
+    async put(key, bins, meta) {
+        const client = this.requireClient();
+        try {
+            return await client.put(this.makeKey(key), bins, meta);
+        }
+        catch (err) {
+            throw this.wrapError('put', err);
+        }
+    }
+    /** Reads a record by key, returning its bins (`record.bins`), or throws if it doesn't exist. */
+    async get(key) {
+        const client = this.requireClient();
+        try {
+            const record = await client.get(this.makeKey(key));
+            return record.bins;
+        }
+        catch (err) {
+            throw this.wrapError('get', err);
+        }
+    }
+    /** Removes a record by key. */
+    async remove(key) {
+        const client = this.requireClient();
+        try {
+            return await client.remove(this.makeKey(key));
+        }
+        catch (err) {
+            throw this.wrapError('remove', err);
+        }
+    }
+    /** Returns whether a record exists for the given key. */
+    async exists(key) {
+        const client = this.requireClient();
+        try {
+            return await client.exists(this.makeKey(key));
+        }
+        catch (err) {
+            throw this.wrapError('exists', err);
+        }
+    }
+    /**
+     * Runs an ordered list of operations atomically against a single record
+     * (Aerospike's `operate` — increment, append, read-back, etc). `ops` is
+     * passed straight through to the driver; build them with the driver's own
+     * operation helpers.
+     */
+    async operate(key, ops) {
+        const client = this.requireClient();
+        try {
+            return await client.operate(this.makeKey(key), ops);
+        }
+        catch (err) {
+            throw this.wrapError('operate', err);
+        }
+    }
+    /**
+     * Truncates a set (or the store's default set), deleting every record in it.
+     * `beforeNanos` of `0` means "everything up to now". Requires a driver whose
+     * client exposes `truncate()`.
+     */
+    async truncate(set) {
+        const client = this.requireClient();
+        if (typeof client.truncate !== 'function') {
+            throw new errors_1.DatabaseError('Aerospike truncate() is not supported by this client', {
+                original: 'client.truncate is not a function',
+            });
+        }
+        try {
+            return await client.truncate(this.namespace, set ?? this.set ?? null, 0);
+        }
+        catch (err) {
+            throw this.wrapError('truncate', err);
+        }
+    }
+}
+exports.AerospikeStore = AerospikeStore;
+exports.default = AerospikeStore;

package/dist/nosql/allegrograph/index.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * AllegroGraph store implementation.
+ *
+ * AllegroGraph is a semantic-graph / RDF triplestore. Its repositories are
+ * queried over the SPARQL 1.1 Protocol via a per-repository HTTP endpoint
+ * (`/repositories/<repo>`) used for both queries and updates. There is no
+ * SQL-shaped surface, so it implements the minimal `NoSqlStore` marker
+ * interface (`src/nosql/store.ts`) rather than the SQL `Dialect` interface.
+ *
+ * ## Driver strategy - prefer HTTP over `fetch`
+ *
+ * AllegroGraph ships an `agraph-js` client, but this store prefers the plain
+ * SPARQL/HTTP protocol over the global `fetch` so it has no hard dependency
+ * (`library='fetch'`). For tests (and for callers who want their own
+ * transport) an alternative client can be injected via
+ * `AllegrographStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `endpoint` is built at connect time.
+ *
+ * ## Surface
+ *
+ * - `query(sparql)`  -> POST to `/repositories/<repo>`, returns bindings
+ * - `update(sparql)` -> POST to `/repositories/<repo>`
+ * - `ask(sparql)`    -> POST an ASK query, returns the boolean
+ * - `add(triples)`   -> `INSERT DATA { ... }` update
+ * - `drop(graph?)`   -> `DROP GRAPH <g>` / `DROP ALL` update
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllegrographStore = exports.DEFAULT_ALLEGROGRAPH_REPOSITORY = exports.DEFAULT_ALLEGROGRAPH_ENDPOINT = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default AllegroGraph base URL. */
+exports.DEFAULT_ALLEGROGRAPH_ENDPOINT = 'http://localhost:10035';
+/** Default repository id. */
+exports.DEFAULT_ALLEGROGRAPH_REPOSITORY = 'repo';
+/** Build a `fetch`-backed SPARQL client for the given endpoint. */
+function createFetchClient(endpoint, headers) {
+    const base = endpoint.endsWith('/') ? endpoint : `${endpoint}/`;
+    const buildUrl = (path) => new URL(path.replace(/^\//, ''), base).toString();
+    return {
+        async query(path, sparql) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/sparql-query',
+                    Accept: 'application/sparql-results+json',
+                    ...(headers ?? {}),
+                },
+                body: sparql,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return res.json();
+        },
+        async update(path, sparql) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/sparql-update', ...(headers ?? {}) },
+                body: sparql,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            const text = await res.text();
+            return text || undefined;
+        },
+    };
+}
+/**
+ * `AllegrographStore` wraps an AllegroGraph repository's SPARQL endpoint behind
+ * the `NoSqlStore` lifecycle.
+ */
+class AllegrographStore {
+    constructor(options = {}) {
+        this.name = 'allegrograph';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.endpoint = options.endpoint ?? exports.DEFAULT_ALLEGROGRAPH_ENDPOINT;
+        this.repository = options.repository ?? exports.DEFAULT_ALLEGROGRAPH_REPOSITORY;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    /** SPARQL query endpoint path for the configured repository. */
+    get queryPath() {
+        return `/repositories/${this.repository}`;
+    }
+    /** SPARQL update endpoint path for the configured repository (same endpoint). */
+    get updatePath() {
+        return `/repositories/${this.repository}`;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client)
+            return;
+        this.client = this.injectedClient ?? createFetchClient(this.endpoint, this.headers);
+        this.connected = true;
+    }
+    async disconnect() {
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying (internal or injected) SPARQL HTTP client. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to AllegroGraph', {
+                database: 'allegrograph',
+                host: this.endpoint,
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // SPARQL surface
+    // ---------------------------------------------------------------------
+    /** Runs a SPARQL SELECT/CONSTRUCT query; returns the result bindings. */
+    async query(sparql) {
+        const client = this.requireClient();
+        try {
+            const body = await client.query(this.queryPath, sparql);
+            return body?.results?.bindings ?? [];
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `AllegroGraph query failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Runs a SPARQL ASK query; returns the boolean answer. */
+    async ask(sparql) {
+        const client = this.requireClient();
+        try {
+            const body = await client.query(this.queryPath, sparql);
+            return Boolean(body?.boolean);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `AllegroGraph ask failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Runs a SPARQL UPDATE (INSERT/DELETE/DROP/...). */
+    async update(sparql) {
+        const client = this.requireClient();
+        try {
+            return await client.update(this.updatePath, sparql);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `AllegroGraph update failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Inserts triples via `INSERT DATA { ... }`. Accepts a triple string or array. */
+    async add(triples, graph) {
+        const body = Array.isArray(triples) ? triples.join('\n') : triples;
+        const inner = graph ? `GRAPH <${graph}> { ${body} }` : body;
+        return this.update(`INSERT DATA { ${inner} }`);
+    }
+    /** Drops a named graph, or all graphs when no graph is given. */
+    async drop(graph) {
+        return this.update(graph ? `DROP GRAPH <${graph}>` : 'DROP ALL');
+    }
+}
+exports.AllegrographStore = AllegrographStore;