@anysoftinc/anydb-sdk 0.1.1

package/dist/nextauth-adapter.js

@@ -0,0 +1,340 @@
+import { SchemaBuilder, DatomicUtils, kw, sym, uuid as uuidEdn } from "./client";
+// Datomic schema idents
+const USER = {
+    id: ":auth.user.v1/id", // uuid identity
+    name: ":auth.user.v1/name",
+    email: ":auth.user.v1/email",
+    emailVerified: ":auth.user.v1/email-verified",
+    image: ":auth.user.v1/image",
+};
+const ACCOUNT = {
+    id: ":auth.account.v1/id", // uuid identity
+    userId: ":auth.account.v1/user-id", // uuid ref by value
+    type: ":auth.account.v1/type",
+    provider: ":auth.account.v1/provider",
+    providerAccountId: ":auth.account.v1/provider-account-id",
+    refreshToken: ":auth.account.v1/refresh-token",
+    accessToken: ":auth.account.v1/access-token",
+    expiresAt: ":auth.account.v1/expires-at",
+    tokenType: ":auth.account.v1/token-type",
+    scope: ":auth.account.v1/scope",
+    idToken: ":auth.account.v1/id-token",
+    sessionState: ":auth.account.v1/session-state",
+};
+const SESSION = {
+    id: ":auth.session.v1/id", // uuid identity
+    sessionToken: ":auth.session.v1/session-token",
+    userId: ":auth.session.v1/user-id",
+    expires: ":auth.session.v1/expires",
+};
+const VTOKEN = {
+    id: ":auth.vtoken.v1/id", // uuid identity
+    identifier: ":auth.vtoken.v1/identifier",
+    token: ":auth.vtoken.v1/token",
+    expires: ":auth.vtoken.v1/expires",
+};
+async function ensureAuthSchema(db) {
+    const defs = [];
+    // Helper to conditionally add attribute definitions
+    const addAttr = async (ident, vt, card, opts = {}) => {
+        const exists = await db.querySymbolic({ find: [sym("?e")], where: [[sym("?e"), kw(":db/ident"), kw(ident)]] });
+        if (!exists || (Array.isArray(exists) && exists.length === 0)) {
+            defs.push(SchemaBuilder.attribute({ ":db/ident": ident, ":db/valueType": vt, ":db/cardinality": card, ...opts }));
+        }
+    };
+    // User attributes
+    await addAttr(USER.id, ":db.type/uuid", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(USER.name, ":db.type/string", ":db.cardinality/one");
+    // Make email an identity attribute so we can upsert users by email
+    await addAttr(USER.email, ":db.type/string", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(USER.emailVerified, ":db.type/instant", ":db.cardinality/one");
+    await addAttr(USER.image, ":db.type/string", ":db.cardinality/one");
+    // Account attributes
+    await addAttr(ACCOUNT.id, ":db.type/uuid", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(ACCOUNT.userId, ":db.type/uuid", ":db.cardinality/one", { ":db/index": true });
+    await addAttr(ACCOUNT.type, ":db.type/string", ":db.cardinality/one");
+    await addAttr(ACCOUNT.provider, ":db.type/string", ":db.cardinality/one", { ":db/index": true });
+    await addAttr(ACCOUNT.providerAccountId, ":db.type/string", ":db.cardinality/one", { ":db/index": true });
+    await addAttr(ACCOUNT.refreshToken, ":db.type/string", ":db.cardinality/one");
+    await addAttr(ACCOUNT.accessToken, ":db.type/string", ":db.cardinality/one");
+    await addAttr(ACCOUNT.expiresAt, ":db.type/long", ":db.cardinality/one");
+    await addAttr(ACCOUNT.tokenType, ":db.type/string", ":db.cardinality/one");
+    await addAttr(ACCOUNT.scope, ":db.type/string", ":db.cardinality/one");
+    await addAttr(ACCOUNT.idToken, ":db.type/string", ":db.cardinality/one");
+    await addAttr(ACCOUNT.sessionState, ":db.type/string", ":db.cardinality/one");
+    // Session attributes
+    await addAttr(SESSION.id, ":db.type/uuid", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(SESSION.userId, ":db.type/uuid", ":db.cardinality/one", { ":db/index": true });
+    await addAttr(SESSION.sessionToken, ":db.type/string", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(SESSION.expires, ":db.type/instant", ":db.cardinality/one");
+    // Verification token attributes
+    await addAttr(VTOKEN.id, ":db.type/uuid", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(VTOKEN.identifier, ":db.type/string", ":db.cardinality/one", { ":db/index": true });
+    await addAttr(VTOKEN.token, ":db.type/string", ":db.cardinality/one", { ":db/unique": ":db.unique/identity", ":db/index": true });
+    await addAttr(VTOKEN.expires, ":db.type/instant", ":db.cardinality/one");
+    // Install schema if there are new definitions
+    if (defs.length) {
+        try {
+            await db.transact(defs);
+        }
+        catch (e) {
+            // Schema attributes may already exist, which is fine
+        }
+    }
+}
+function toUser(m) {
+    const get = (k) => m && (m[k] ?? m[`:${k}`]);
+    // USER.id is ":auth.user.v1/id", so slice(1) gives "auth.user.v1/id"
+    const idKey = USER.id.slice(1); // "auth.user.v1/id"  
+    const idVal = get(idKey);
+    const id = typeof idVal === 'string' ? idVal : idVal?.value ?? String(idVal);
+    const emailVerified = get(USER.emailVerified.slice(1));
+    return {
+        id,
+        name: get(USER.name.slice(1)) || null,
+        email: get(USER.email.slice(1)) || null,
+        emailVerified: emailVerified ? new Date(emailVerified) : null,
+        image: get(USER.image.slice(1)) || null,
+    };
+}
+/**
+ * Creates a NextAuth.js adapter for AnyDB/Datomic
+ *
+ * @param db - DatomicDatabase instance
+ * @returns NextAuth.js Adapter
+ *
+ * @example
+ * ```typescript
+ * import { createDatomicDatabase } from '@anysoftinc/anydb-sdk';
+ * import { AnyDBAdapter } from '@anysoftinc/anydb-sdk/nextauth-adapter';
+ *
+ * const db = createDatomicDatabase(client, 'storage', 'auth-db');
+ *
+ * export default NextAuth({
+ *   adapter: AnyDBAdapter(db),
+ *   // ... other config
+ * });
+ * ```
+ */
+export function AnyDBAdapter(db) {
+    async function getUserByEmail(email) {
+        await ensureAuthSchema(db);
+        const q = `[:find (pull ?e [${USER.id} ${USER.name} ${USER.email} ${USER.emailVerified} ${USER.image}]) :where [?e ${USER.email} "${email}"]]`;
+        const res = await db.query(q);
+        const rows = Array.isArray(res) ? res : [];
+        return rows.length ? toUser(rows[0][0]) : null;
+    }
+    async function getUser(id) {
+        await ensureAuthSchema(db);
+        const q = `[:find (pull ?e [${USER.id} ${USER.name} ${USER.email} ${USER.emailVerified} ${USER.image}]) :where [?e ${USER.id} #uuid "${id}"]]`;
+        const res = await db.query(q);
+        const rows = Array.isArray(res) ? res : [];
+        if (!rows.length)
+            return null;
+        return toUser(rows[0][0]);
+    }
+    return {
+        // Users
+        async createUser(data) {
+            await ensureAuthSchema(db);
+            // Check if user already exists by email
+            if (data.email) {
+                const existing = await getUserByEmail(data.email);
+                if (existing) {
+                    return existing;
+                }
+            }
+            const id = globalThis.crypto?.randomUUID?.() || (await import("crypto")).randomUUID();
+            const tx = {
+                'db/id': DatomicUtils.tempId(),
+                [USER.id]: uuidEdn(id),
+                ...(data.name ? { [USER.name]: data.name } : {}),
+                ...(data.email ? { [USER.email]: data.email } : {}),
+                ...(data.emailVerified ? { [USER.emailVerified]: data.emailVerified } : {}),
+                ...(data.image ? { [USER.image]: data.image } : {}),
+            };
+            await db.transact([tx]);
+            return {
+                id,
+                name: data.name ?? null,
+                email: data.email ?? null,
+                emailVerified: data.emailVerified ?? null,
+                image: data.image ?? null
+            };
+        },
+        getUser,
+        getUserByEmail,
+        async getUserByAccount({ provider, providerAccountId }) {
+            await ensureAuthSchema(db);
+            const q = `[:find (pull ?u [${USER.id} ${USER.name} ${USER.email} ${USER.emailVerified} ${USER.image}])
+                 :where [?a ${ACCOUNT.provider} "${provider}"]
+                        [?a ${ACCOUNT.providerAccountId} "${providerAccountId}"]
+                        [?a ${ACCOUNT.userId} ?uid]
+                        [?u ${USER.id} ?uid]]`;
+            const res = await db.query(q);
+            const rows = Array.isArray(res) ? res : [];
+            return rows.length ? toUser(rows[0][0]) : null;
+        },
+        async updateUser(data) {
+            await ensureAuthSchema(db);
+            if (!data.id)
+                throw new Error("updateUser requires id");
+            const tx = {
+                'db/id': DatomicUtils.tempId(),
+                [USER.id]: uuidEdn(data.id),
+                ...(data.name !== undefined ? { [USER.name]: data.name } : {}),
+                ...(data.email !== undefined ? { [USER.email]: data.email } : {}),
+                ...(data.emailVerified !== undefined ? { [USER.emailVerified]: data.emailVerified } : {}),
+                ...(data.image !== undefined ? { [USER.image]: data.image } : {}),
+            };
+            await db.transact([tx]);
+            const u = await getUser(data.id);
+            return u;
+        },
+        async deleteUser(id) {
+            await ensureAuthSchema(db);
+            await db.transact([[":db/retractEntity", [USER.id], uuidEdn(id)]]);
+            return null;
+        },
+        // Accounts
+        async linkAccount(account) {
+            await ensureAuthSchema(db);
+            const id = globalThis.crypto?.randomUUID?.() || (await import("crypto")).randomUUID();
+            const tx = {
+                'db/id': DatomicUtils.tempId(),
+                [ACCOUNT.id]: uuidEdn(id),
+                [ACCOUNT.userId]: uuidEdn(account.userId),
+                [ACCOUNT.type]: account.type,
+                [ACCOUNT.provider]: account.provider,
+                [ACCOUNT.providerAccountId]: account.providerAccountId,
+                ...(account.refresh_token ? { [ACCOUNT.refreshToken]: account.refresh_token } : {}),
+                ...(account.access_token ? { [ACCOUNT.accessToken]: account.access_token } : {}),
+                ...(account.expires_at ? { [ACCOUNT.expiresAt]: account.expires_at } : {}),
+                ...(account.token_type ? { [ACCOUNT.tokenType]: account.token_type } : {}),
+                ...(account.scope ? { [ACCOUNT.scope]: account.scope } : {}),
+                ...(account.id_token ? { [ACCOUNT.idToken]: account.id_token } : {}),
+                ...(account.session_state ? { [ACCOUNT.sessionState]: account.session_state } : {}),
+            };
+            await db.transact([tx]);
+            return account;
+        },
+        async unlinkAccount({ provider, providerAccountId }) {
+            await ensureAuthSchema(db);
+            const q = `[:find ?id :where [?a ${ACCOUNT.provider} "${provider}"] [?a ${ACCOUNT.providerAccountId} "${providerAccountId}"] [?a ${ACCOUNT.id} ?id]]`;
+            const res = await db.query(q);
+            const id = Array.isArray(res) && res[0]?.[0];
+            if (id) {
+                await db.transact([[":db/retractEntity", [ACCOUNT.id], id]]);
+            }
+        },
+        // Sessions
+        async createSession(session) {
+            await ensureAuthSchema(db);
+            const id = globalThis.crypto?.randomUUID?.() || (await import("crypto")).randomUUID();
+            let expiresDate;
+            if (session.expires instanceof Date && !isNaN(session.expires.getTime())) {
+                expiresDate = session.expires;
+            }
+            else if (session.expires) {
+                const d = new Date(session.expires);
+                expiresDate = isNaN(d.getTime()) ? new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) : d;
+            }
+            else {
+                expiresDate = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000);
+            }
+            const tx = {
+                'db/id': DatomicUtils.tempId(),
+                [SESSION.id]: uuidEdn(id),
+                [SESSION.userId]: uuidEdn(session.userId),
+                [SESSION.sessionToken]: session.sessionToken,
+                [SESSION.expires]: expiresDate,
+            };
+            await db.transact([tx]);
+            return { ...session, expires: expiresDate };
+        },
+        async getSessionAndUser(sessionToken) {
+            await ensureAuthSchema(db);
+            const q = `[:find (pull ?s [${SESSION.id} ${SESSION.sessionToken} ${SESSION.userId} ${SESSION.expires}]) (pull ?u [${USER.id} ${USER.name} ${USER.email} ${USER.emailVerified} ${USER.image}])
+                 :where [?s ${SESSION.sessionToken} "${sessionToken}"]
+                        [?s ${SESSION.userId} ?uid]
+                        [?u ${USER.id} ?uid]]`;
+            const res = await db.query(q);
+            const row = Array.isArray(res) ? res[0] : null;
+            if (!row)
+                return null;
+            const s = row[0];
+            const u = row[1];
+            const getS = (k) => s && (s[k] ?? s[`:${k}`]);
+            const expiresRaw = getS(SESSION.expires.slice(1));
+            const expires = expiresRaw instanceof Date ? expiresRaw : new Date(expiresRaw);
+            const sessionResult = {
+                sessionToken: getS(SESSION.sessionToken.slice(1)),
+                userId: (getS(SESSION.userId.slice(1))?.value ?? getS(SESSION.userId.slice(1))),
+                expires,
+            };
+            return { session: sessionResult, user: toUser(u) };
+        },
+        async updateSession(partial) {
+            await ensureAuthSchema(db);
+            let expiresDate;
+            if (partial.expires instanceof Date) {
+                expiresDate = isNaN(partial.expires.getTime()) ? undefined : partial.expires;
+            }
+            else if (partial.expires) {
+                const d = new Date(partial.expires);
+                expiresDate = isNaN(d.getTime()) ? undefined : d;
+            }
+            const tx = {
+                'db/id': DatomicUtils.tempId(),
+                ...(partial.sessionToken ? { [SESSION.sessionToken]: partial.sessionToken } : {}),
+                ...(partial.userId ? { [SESSION.userId]: uuidEdn(partial.userId) } : {}),
+                ...(expiresDate ? { [SESSION.expires]: expiresDate } : {}),
+            };
+            await db.transact([tx]);
+            return { ...partial, ...(expiresDate ? { expires: expiresDate } : {}) };
+        },
+        async deleteSession(sessionToken) {
+            await ensureAuthSchema(db);
+            const q = `[:find ?id :where [?s ${SESSION.sessionToken} "${sessionToken}"] [?s ${SESSION.id} ?id]]`;
+            const res = await db.query(q);
+            const id = Array.isArray(res) && res[0]?.[0];
+            if (id) {
+                await db.transact([[":db/retractEntity", [SESSION.id], id]]);
+            }
+        },
+        // Verification tokens (email sign-in, passwordless)
+        async createVerificationToken(token) {
+            await ensureAuthSchema(db);
+            const id = globalThis.crypto?.randomUUID?.() || (await import("crypto")).randomUUID();
+            const tx = {
+                'db/id': DatomicUtils.tempId(),
+                [VTOKEN.id]: uuidEdn(id),
+                [VTOKEN.identifier]: token.identifier,
+                [VTOKEN.token]: token.token,
+                [VTOKEN.expires]: token.expires,
+            };
+            await db.transact([tx]);
+            return token;
+        },
+        async useVerificationToken(params) {
+            await ensureAuthSchema(db);
+            const q = `[:find (pull ?e [${VTOKEN.id} ${VTOKEN.identifier} ${VTOKEN.token} ${VTOKEN.expires}])
+                 :where [?e ${VTOKEN.identifier} "${params.identifier}"]
+                        [?e ${VTOKEN.token} "${params.token}"]]`;
+            const res = await db.query(q);
+            const rows = Array.isArray(res) ? res : [];
+            if (!rows.length)
+                return null;
+            const m = rows[0][0];
+            const get = (k) => m && (m[k] ?? m[`:${k}`]);
+            const entityId = get(VTOKEN.id.slice(1));
+            // Delete the token after using it
+            await db.transact([[":db/retractEntity", [VTOKEN.id], entityId]]);
+            return {
+                identifier: get(VTOKEN.identifier.slice(1)),
+                token: get(VTOKEN.token.slice(1)),
+                expires: new Date(get(VTOKEN.expires.slice(1))),
+            };
+        },
+    };
+}

package/dist/query-builder.d.ts

@@ -0,0 +1,126 @@
+import { QueryInput, QueryResult, QueryValue, Keyword, Symbol } from './client';
+import type { DatomicDatabase } from './client';
+export type QueryVariable = Symbol;
+export interface QueryPattern {
+    entity: QueryValue;
+    attribute: QueryValue;
+    value: QueryValue;
+    tx?: QueryValue;
+}
+export interface AggregationClause {
+    function: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'count-distinct';
+    variable: QueryVariable;
+    alias?: QueryVariable;
+}
+export declare class QueryBuilder {
+    private findClause;
+    private whereClause;
+    private inClause;
+    private withClause;
+    /**
+     * Add variables or aggregations to the :find clause
+     * @example
+     * .find(sym('?e'), sym('?name')) // Find entity and name
+     * .find({ function: 'count', variable: sym('?e') }) // Count entities
+     */
+    find(...vars: (QueryVariable | AggregationClause)[]): this;
+    /**
+     * Add a structured where clause
+     * @example
+     * .where({ entity: sym('?e'), attribute: kw(':person/name'), value: sym('?name') })
+     */
+    where(clause: QueryPattern): this;
+    /**
+     * Helper method to add entity-attribute-value pattern
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name')).withValue(sym('?name'))
+     */
+    entity(entity: QueryValue): EntityQueryBuilder;
+    /**
+     * Add input parameters to the :in clause
+     * @example
+     * .in(sym('$')) // Database input
+     * .in(sym('?name')) // Parameter input
+     */
+    in(...inputs: QueryVariable[]): this;
+    /**
+     * Add variables to the :with clause
+     * @example
+     * .with(sym('?tx')) // Include transaction in results
+     */
+    with(...variables: QueryVariable[]): this;
+    /**
+     * Helper for common patterns - find entities with attribute
+     * @example
+     * .findEntitiesWith(kw(':person/name')) // Find entities with any name
+     * .findEntitiesWith(kw(':person/name'), sym('?name')) // Bind name to variable
+     * .findEntitiesWith(kw(':person/name'), 'John') // Find entities named John
+     */
+    findEntitiesWith(attribute: Keyword, value?: QueryValue): this;
+    /**
+     * Helper for aggregation queries
+     * @example
+     * .count(sym('?e')) // Count entities
+     * .sum(sym('?amount')) // Sum amounts
+     */
+    count(variable: QueryVariable, alias?: QueryVariable): this;
+    sum(variable: QueryVariable, alias?: QueryVariable): this;
+    avg(variable: QueryVariable, alias?: QueryVariable): this;
+    min(variable: QueryVariable, alias?: QueryVariable): this;
+    max(variable: QueryVariable, alias?: QueryVariable): this;
+    countDistinct(variable: QueryVariable, alias?: QueryVariable): this;
+    /**
+     * Build the final query array with proper EDN types
+     */
+    build(): QueryInput;
+    /**
+     * Execute the query directly (requires database context)
+     */
+    execute(db: DatomicDatabase, ...args: any[]): Promise<QueryResult>;
+}
+/**
+ * Helper class for fluent entity-based query building
+ */
+export declare class EntityQueryBuilder {
+    private queryBuilder;
+    private entity;
+    constructor(queryBuilder: QueryBuilder, entity: QueryValue);
+    /**
+     * Add an attribute to the current entity
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name'))
+     */
+    hasAttribute(attribute: Keyword): AttributeQueryBuilder;
+    /**
+     * Return to the main query builder
+     */
+    build(): QueryInput;
+}
+/**
+ * Helper class for fluent attribute-based query building
+ */
+export declare class AttributeQueryBuilder {
+    private queryBuilder;
+    private entity;
+    private attribute;
+    constructor(queryBuilder: QueryBuilder, entity: QueryValue, attribute: Keyword);
+    /**
+     * Add a value constraint to the attribute
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name')).withValue(sym('?name'))
+     * .entity(sym('?e')).hasAttribute(kw(':person/age')).withValue(25)
+     */
+    withValue(value: QueryValue): QueryBuilder;
+    /**
+     * Add the attribute without a specific value constraint (will bind to a variable)
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name')).bind()
+     */
+    bind(variable?: QueryVariable): QueryBuilder;
+    private generateVariable;
+    /**
+     * Return to the main query builder
+     */
+    build(): QueryInput;
+}
+//# sourceMappingURL=query-builder.d.ts.map

package/dist/query-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../src/query-builder.ts"],"names":[],"mappings":"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"}

package/dist/query-builder.js

@@ -0,0 +1,207 @@
+import { kw, sym } from './client';
+export class QueryBuilder {
+    constructor() {
+        this.findClause = [];
+        this.whereClause = [];
+        this.inClause = [];
+        this.withClause = [];
+    }
+    /**
+     * Add variables or aggregations to the :find clause
+     * @example
+     * .find(sym('?e'), sym('?name')) // Find entity and name
+     * .find({ function: 'count', variable: sym('?e') }) // Count entities
+     */
+    find(...vars) {
+        this.findClause.push(...vars);
+        return this;
+    }
+    /**
+     * Add a structured where clause
+     * @example
+     * .where({ entity: sym('?e'), attribute: kw(':person/name'), value: sym('?name') })
+     */
+    where(clause) {
+        this.whereClause.push(clause);
+        return this;
+    }
+    /**
+     * Helper method to add entity-attribute-value pattern
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name')).withValue(sym('?name'))
+     */
+    entity(entity) {
+        return new EntityQueryBuilder(this, entity);
+    }
+    /**
+     * Add input parameters to the :in clause
+     * @example
+     * .in(sym('$')) // Database input
+     * .in(sym('?name')) // Parameter input
+     */
+    in(...inputs) {
+        this.inClause.push(...inputs);
+        return this;
+    }
+    /**
+     * Add variables to the :with clause
+     * @example
+     * .with(sym('?tx')) // Include transaction in results
+     */
+    with(...variables) {
+        this.withClause.push(...variables);
+        return this;
+    }
+    /**
+     * Helper for common patterns - find entities with attribute
+     * @example
+     * .findEntitiesWith(kw(':person/name')) // Find entities with any name
+     * .findEntitiesWith(kw(':person/name'), sym('?name')) // Bind name to variable
+     * .findEntitiesWith(kw(':person/name'), 'John') // Find entities named John
+     */
+    findEntitiesWith(attribute, value) {
+        const entity = sym('?e');
+        const valueToUse = value !== undefined ? value : sym('?value');
+        // Only add value to find clause if it's a variable
+        if (value === undefined || (typeof valueToUse === 'object' && valueToUse && valueToUse._type === 'symbol')) {
+            this.find(entity, valueToUse);
+        }
+        else {
+            this.find(entity);
+        }
+        this.where({ entity, attribute, value: valueToUse });
+        return this;
+    }
+    /**
+     * Helper for aggregation queries
+     * @example
+     * .count(sym('?e')) // Count entities
+     * .sum(sym('?amount')) // Sum amounts
+     */
+    count(variable, alias) {
+        return this.find({ function: 'count', variable, alias });
+    }
+    sum(variable, alias) {
+        return this.find({ function: 'sum', variable, alias });
+    }
+    avg(variable, alias) {
+        return this.find({ function: 'avg', variable, alias });
+    }
+    min(variable, alias) {
+        return this.find({ function: 'min', variable, alias });
+    }
+    max(variable, alias) {
+        return this.find({ function: 'max', variable, alias });
+    }
+    countDistinct(variable, alias) {
+        return this.find({ function: 'count-distinct', variable, alias });
+    }
+    /**
+     * Build the final query array with proper EDN types
+     */
+    build() {
+        const query = [kw(":find")];
+        // Add find clause
+        this.findClause.forEach(item => {
+            if (typeof item === 'object' && item && item._type === 'symbol') {
+                query.push(item);
+            }
+            else {
+                // Aggregation function
+                const agg = item;
+                // Build aggregation as a list: (count ?e)
+                const aggList = [sym(agg.function), agg.variable];
+                query.push(agg.alias || aggList);
+            }
+        });
+        // Add in clause
+        if (this.inClause.length > 0) {
+            query.push(kw(":in"), ...this.inClause);
+        }
+        // Add with clause
+        if (this.withClause.length > 0) {
+            query.push(kw(":with"), ...this.withClause);
+        }
+        // Add where clause
+        if (this.whereClause.length > 0) {
+            query.push(kw(":where"));
+            this.whereClause.forEach(clause => {
+                // Convert QueryPattern to array format
+                const clauseArray = [clause.entity, clause.attribute, clause.value];
+                if (clause.tx)
+                    clauseArray.push(clause.tx);
+                query.push(clauseArray);
+            });
+        }
+        return query;
+    }
+    /**
+     * Execute the query directly (requires database context)
+     */
+    async execute(db, ...args) {
+        return db.query(this.build(), ...args);
+    }
+}
+/**
+ * Helper class for fluent entity-based query building
+ */
+export class EntityQueryBuilder {
+    constructor(queryBuilder, entity) {
+        this.queryBuilder = queryBuilder;
+        this.entity = entity;
+    }
+    /**
+     * Add an attribute to the current entity
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name'))
+     */
+    hasAttribute(attribute) {
+        return new AttributeQueryBuilder(this.queryBuilder, this.entity, attribute);
+    }
+    /**
+     * Return to the main query builder
+     */
+    build() {
+        return this.queryBuilder.build();
+    }
+}
+/**
+ * Helper class for fluent attribute-based query building
+ */
+export class AttributeQueryBuilder {
+    constructor(queryBuilder, entity, attribute) {
+        this.queryBuilder = queryBuilder;
+        this.entity = entity;
+        this.attribute = attribute;
+    }
+    /**
+     * Add a value constraint to the attribute
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name')).withValue(sym('?name'))
+     * .entity(sym('?e')).hasAttribute(kw(':person/age')).withValue(25)
+     */
+    withValue(value) {
+        this.queryBuilder.where({ entity: this.entity, attribute: this.attribute, value });
+        return this.queryBuilder;
+    }
+    /**
+     * Add the attribute without a specific value constraint (will bind to a variable)
+     * @example
+     * .entity(sym('?e')).hasAttribute(kw(':person/name')).bind()
+     */
+    bind(variable) {
+        const value = variable || this.generateVariable();
+        this.queryBuilder.where({ entity: this.entity, attribute: this.attribute, value });
+        return this.queryBuilder;
+    }
+    generateVariable() {
+        const attrName = this.attribute.value.split('/').pop()?.replace(/[^a-zA-Z0-9]/g, '');
+        return sym(`?${attrName}`);
+    }
+    /**
+     * Return to the main query builder
+     */
+    build() {
+        return this.queryBuilder.build();
+    }
+}