@anysoftinc/anydb-sdk 0.1.1

package/dist/client.js

@@ -0,0 +1,397 @@
+// Core types for Datomic data model
+import { parseEDNString as parseEdn } from "edn-data";
+export const sym = (name) => ({ _type: 'symbol', value: name });
+export const uuid = (id) => ({ _type: 'uuid', value: id });
+export const kw = (name) => ({ _type: 'keyword', value: name });
+/**
+ * Enhanced EDN stringifier with support for symbolic types
+ */
+export function stringifyEdn(obj) {
+    // Handle symbolic types first
+    if (typeof obj === "object" && obj !== null && "_type" in obj) {
+        const typed = obj;
+        switch (typed._type) {
+            case 'symbol':
+                return typed.value; // ?e, ?id, etc.
+            case 'uuid':
+                return `#uuid "${typed.value}"`;
+            case 'keyword':
+                return typed.value.startsWith(':') ? typed.value : `:${typed.value}`;
+        }
+    }
+    if (typeof obj === "string") {
+        // Keywords and symbols don't get quoted, strings do
+        if (obj.startsWith(":") || obj.startsWith("?")) {
+            return obj;
+        }
+        return `"${obj.replace(/"/g, '\\"')}"`;
+    }
+    if (typeof obj === "number")
+        return String(obj);
+    if (typeof obj === "boolean")
+        return String(obj);
+    if (obj === null || obj === undefined)
+        return "nil";
+    if (obj instanceof Date)
+        return `#inst "${obj.toISOString()}"`;
+    if (Array.isArray(obj)) {
+        return "[" + obj.map(stringifyEdn).join(" ") + "]";
+    }
+    if (typeof obj === "object") {
+        const pairs = Object.entries(obj).map(([key, value]) => {
+            // Handle Datomic keyword keys
+            const ednKey = key.startsWith(":") ? key : `:${key}`;
+            return `${ednKey} ${stringifyEdn(value)}`;
+        });
+        return "{" + pairs.join(" ") + "}";
+    }
+    return String(obj);
+}
+// Main SDK Client
+export class DatomicClient {
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = config.baseUrl.replace(/\/$/, ""); // Remove trailing slash
+    }
+    // Normalize EDN parsed values to JS-friendly shapes
+    normalizeEdn(value) {
+        if (value === null || value === undefined)
+            return value;
+        // edn-data often wraps symbols/keywords/strings as { key: '...' }
+        if (typeof value === 'object' && value && typeof value.key === 'string') {
+            return value.key;
+        }
+        // Sets -> Arrays
+        if (value instanceof Set) {
+            return Array.from(value, (v) => this.normalizeEdn(v));
+        }
+        // edn-data set representation: { set: [...] }
+        if (typeof value === 'object' && value && Array.isArray(value.set)) {
+            return value.set.map((v) => this.normalizeEdn(v));
+        }
+        // edn-data map representation: { map: [[k,v] ...] }
+        if (typeof value === 'object' && value && Array.isArray(value.map)) {
+            const out = {};
+            for (const [k, v] of value.map) {
+                const keyNorm = this.normalizeEdn(k);
+                const keyStr = typeof keyNorm === 'string' ? keyNorm : String(keyNorm);
+                out[keyStr] = this.normalizeEdn(v);
+            }
+            return out;
+        }
+        // Arrays
+        if (Array.isArray(value)) {
+            return value.map((v) => this.normalizeEdn(v));
+        }
+        // Objects: attempt to descend shallowly
+        if (typeof value === 'object') {
+            // Convert common UUID representations to a consistent shape
+            if (value.tag === 'uuid' && typeof value.val === 'string') {
+                return { _type: 'uuid', value: value.val };
+            }
+            if (value.type === 'uuid' && typeof value.value === 'string') {
+                return value; // already in {_type:'uuid', value}
+            }
+            // Convert inst tag to Date
+            if (value.tag === 'inst' && typeof value.val === 'string') {
+                const d = new Date(value.val);
+                return isNaN(d.getTime()) ? value.val : d;
+            }
+            const out = Array.isArray(value) ? [] : {};
+            for (const [k, v] of Object.entries(value)) {
+                out[k] = this.normalizeEdn(v);
+            }
+            return out;
+        }
+        return value;
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        // Convert body to EDN if present
+        const processedOptions = { ...options };
+        if (processedOptions.body && typeof processedOptions.body !== "string") {
+            processedOptions.body = stringifyEdn(processedOptions.body);
+        }
+        const response = await fetch(url, {
+            headers: {
+                "Content-Type": "application/edn",
+                Accept: "application/edn",
+                ...this.config.headers,
+                ...options.headers,
+            },
+            ...processedOptions,
+        });
+        if (!response.ok) {
+            throw new Error(`Datomic API error: ${response.status} ${response.statusText}`);
+        }
+        // Parse EDN response
+        const responseText = await response.text();
+        const parsed = parseEdn(responseText);
+        return this.normalizeEdn(parsed);
+    }
+    // List databases in a storage
+    async listDatabases(storageAlias) {
+        return this.request(`/data/${storageAlias}/`);
+    }
+    // Create database
+    async createDatabase(storageAlias, dbName) {
+        return this.request(`/data/${storageAlias}/`, {
+            method: "POST",
+            body: { ":db-name": dbName },
+        });
+    }
+    // Delete database
+    async deleteDatabase(storageAlias, dbName) {
+        return this.request(`/data/${storageAlias}/${dbName}/`, {
+            method: "DELETE",
+        });
+    }
+    // Transaction operations
+    async transact(storageAlias, dbName, txData) {
+        return this.request(`/data/${storageAlias}/${dbName}/`, {
+            method: "POST",
+            body: { ":tx-data": txData },
+        });
+    }
+    // Retrieve database info
+    async databaseInfo(storageAlias, dbName, basisT = "-") {
+        return this.request(`/data/${storageAlias}/${dbName}/${basisT}/`);
+    }
+    // Datoms operations
+    async datoms(storageAlias, dbName, basisT, options) {
+        const params = new URLSearchParams();
+        // Required parameter
+        params.append("index", options.index);
+        // Optional parameters
+        if (options.e !== undefined)
+            params.append("e", String(options.e));
+        if (options.a !== undefined)
+            params.append("a", String(options.a));
+        if (options.v !== undefined)
+            params.append("v", String(options.v));
+        if (options.start !== undefined)
+            params.append("start", String(options.start));
+        if (options.end !== undefined)
+            params.append("end", String(options.end));
+        if (options.limit !== undefined)
+            params.append("limit", String(options.limit));
+        if (options.offset !== undefined)
+            params.append("offset", String(options.offset));
+        if (options["as-of"] !== undefined)
+            params.append("as-of", String(options["as-of"]));
+        if (options.since !== undefined)
+            params.append("since", String(options.since));
+        if (options.history !== undefined)
+            params.append("history", String(options.history));
+        return this.request(`/data/${storageAlias}/${dbName}/${basisT}/datoms?${params.toString()}`);
+    }
+    // Entity operations
+    async entity(storageAlias, dbName, basisT, entityId, options) {
+        const params = new URLSearchParams();
+        params.append("e", String(entityId));
+        if (options?.["as-of"] !== undefined)
+            params.append("as-of", String(options["as-of"]));
+        if (options?.since !== undefined)
+            params.append("since", String(options.since));
+        return this.request(`/data/${storageAlias}/${dbName}/${basisT}/entity?${params.toString()}`);
+    }
+    // Query operations (GET version for simple queries)
+    async queryGet(query, args, options) {
+        const params = new URLSearchParams();
+        params.append("q", stringifyEdn(query));
+        params.append("args", stringifyEdn(args));
+        if (options?.limit !== undefined)
+            params.append("limit", String(options.limit));
+        if (options?.offset !== undefined)
+            params.append("offset", String(options.offset));
+        return this.request(`/api/query?${params.toString()}`);
+    }
+    // Query operations (POST version for complex queries)
+    async query(query, args, options) {
+        const body = {
+            ":q": query,
+            ":args": args,
+        };
+        if (options?.limit !== undefined)
+            body[":limit"] = options.limit;
+        if (options?.offset !== undefined)
+            body[":offset"] = options.offset;
+        const res = await this.request("/api/query", {
+            method: "POST",
+            body: body,
+        });
+        // Ensure result is array of rows, not Set
+        if (res instanceof Set) {
+            return Array.from(res);
+        }
+        return res;
+    }
+    // Symbolic query operations
+    async querySymbolic(query, args = [], options) {
+        // Convert symbolic query to EDN vector format
+        const ednQuery = [":find", ...query.find];
+        if (query.in && query.in.length > 0) {
+            ednQuery.push(":in", ...query.in);
+        }
+        ednQuery.push(":where", ...query.where);
+        return this.query(ednQuery, args, options);
+    }
+    // Server-Sent Events for transaction reports
+    subscribeToEvents(storageAlias, dbName, onEvent, onError) {
+        const eventSource = new EventSource(`${this.baseUrl}/events/${storageAlias}/${dbName}`);
+        eventSource.onmessage = onEvent;
+        if (onError)
+            eventSource.onerror = onError;
+        return eventSource;
+    }
+}
+// Utility functions for common Datomic operations
+export class DatomicUtils {
+    static tempId(partition = "db.part/user") {
+        return `tempid:${partition}:${Math.random().toString(36).substr(2, 9)}`;
+    }
+    static keyword(namespace, name) {
+        return `:${namespace}/${name}`;
+    }
+    static createEntity(attributes, tempId) {
+        const id = tempId || this.tempId();
+        return Object.entries(attributes).map(([attr, value]) => ({
+            "db/id": id,
+            [attr]: value,
+        }));
+    }
+    static retractEntity(entityId) {
+        return [[":db/retractEntity", entityId]];
+    }
+    static retractAttribute(entityId, attribute, value) {
+        if (value !== undefined) {
+            return [[":db/retract", entityId, attribute, value]];
+        }
+        return [[":db/retract", entityId, attribute]];
+    }
+    static addAttribute(entityId, attribute, value) {
+        return [[":db/add", entityId, attribute, value]];
+    }
+}
+export class SchemaBuilder {
+    static attribute(def) {
+        return {
+            "db/id": DatomicUtils.tempId(),
+            ...def,
+        };
+    }
+    static enum(ident, doc) {
+        const enumDef = {
+            "db/id": DatomicUtils.tempId(),
+            ":db/ident": ident,
+        };
+        if (doc) {
+            enumDef[":db/doc"] = doc;
+        }
+        return enumDef;
+    }
+}
+// EDN template literal for natural Datalog queries
+export function edn(strings, ...values) {
+    // Combine template strings and interpolated values
+    let ednString = '';
+    for (let i = 0; i < strings.length; i++) {
+        ednString += strings[i];
+        if (i < values.length) {
+            const value = values[i];
+            // Convert interpolated values to EDN strings
+            ednString += stringifyEdn(value);
+        }
+    }
+    // Use the proper EDN parser
+    const parsed = parseEdn(ednString);
+    // Apply normalization similar to the client's normalizeEdn method
+    return normalizeEdnForQuery(parsed);
+}
+function normalizeEdnForQuery(value) {
+    if (value === null || value === undefined)
+        return value;
+    // Handle edn-data keyword representations: {key: "find"} -> ":find"
+    if (typeof value === 'object' && value && typeof value.key === 'string') {
+        const key = value.key;
+        return key.startsWith(':') ? key : `:${key}`;
+    }
+    // Handle edn-data symbol representations: {sym: "?e"} -> "?e"  
+    if (typeof value === 'object' && value && typeof value.sym === 'string') {
+        return value.sym;
+    }
+    // Handle edn-data list representations: {list: [...]} -> [...]
+    if (typeof value === 'object' && value && Array.isArray(value.list)) {
+        return value.list.map((v) => normalizeEdnForQuery(v));
+    }
+    // Sets -> Arrays  
+    if (value instanceof Set) {
+        return Array.from(value, (v) => normalizeEdnForQuery(v));
+    }
+    // edn-data set representation: { set: [...] }
+    if (typeof value === 'object' && value && Array.isArray(value.set)) {
+        return value.set.map((v) => normalizeEdnForQuery(v));
+    }
+    // Arrays
+    if (Array.isArray(value)) {
+        return value.map((v) => normalizeEdnForQuery(v));
+    }
+    // Convert common UUID representations
+    if (typeof value === 'object' && value && value.tag === 'uuid' && typeof value.val === 'string') {
+        return { _type: 'uuid', value: value.val };
+    }
+    return value;
+}
+// Convenience class for working with a specific database
+export class DatomicDatabase {
+    constructor(client, storageAlias, dbName) {
+        this.client = client;
+        this.storageAlias = storageAlias;
+        this.dbName = dbName;
+    }
+    async transact(txData) {
+        return this.client.transact(this.storageAlias, this.dbName, txData);
+    }
+    async info(basisT = "-") {
+        return this.client.databaseInfo(this.storageAlias, this.dbName, basisT);
+    }
+    async datoms(index, basisT = "-", options) {
+        return this.client.datoms(this.storageAlias, this.dbName, basisT, {
+            index,
+            ...options,
+        });
+    }
+    async entity(entityId, basisT = "-", options) {
+        return this.client.entity(this.storageAlias, this.dbName, basisT, entityId, options);
+    }
+    async query(query, ...args) {
+        const dbDescriptor = {
+            "db/alias": `${this.storageAlias}/${this.dbName}`,
+        };
+        return this.client.query(query, [dbDescriptor, ...args]);
+    }
+    async querySymbolic(query, ...args) {
+        const dbDescriptor = {
+            "db/alias": `${this.storageAlias}/${this.dbName}`,
+        };
+        return this.client.querySymbolic(query, [dbDescriptor, ...args]);
+    }
+    subscribeToEvents(onEvent, onError) {
+        return this.client.subscribeToEvents(this.storageAlias, this.dbName, onEvent, onError);
+    }
+}
+// Factory functions
+export function createDatomicClient(config) {
+    return new DatomicClient(config);
+}
+export function createDatomicDatabase(client, storageAlias, dbName) {
+    return new DatomicDatabase(client, storageAlias, dbName);
+}
+// Small helpers
+export function pluckFirstColumn(rows) {
+    if (!Array.isArray(rows))
+        return [];
+    return rows.map((r) => (Array.isArray(r) ? r[0] : r));
+}
+// Export everything
+export default DatomicClient;

package/dist/nextauth-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { Adapter } from "next-auth/adapters";
+import type { DatomicDatabase } from "./client";
+/**
+ * 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 declare function AnyDBAdapter(db: DatomicDatabase): Adapter;
+//# sourceMappingURL=nextauth-adapter.d.ts.map

package/dist/nextauth-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextauth-adapter.d.ts","sourceRoot":"","sources":["../src/nextauth-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,oBAAoB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAmHhD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CA4PzD"}