driftsql 0.0.1

package/README.md

@@ -0,0 +1,83 @@
+# Drift SQL
+
+Driftsql is a SQL client for libsql and sqlitecloud to provide a simple & fast way to query your data.
+
+## Installation
+
+```bash
+bun add driftsql # or npm install driftsql
+```
+
+## Usage
+
+For now docs are is very basic, but I will add more soon.
+
+Setup client:
+
+```ts
+import { DriftClient } from 'driftsql';
+
+const db = new DriftClient({
+  driver: 'libsql', // More drivers coming soon
+  auth: {
+    url: 'libsql://',
+    token: 'your-token',
+  },
+});
+```
+
+### Type-safety
+
+You can add an type to your database client to get type-safety and autocompletion. Example:
+
+```ts
+import { DriftClient } from 'driftsql';
+
+interface Database {
+  users: {
+    id: number;
+    name: string;
+    email: string;
+    password: string;
+    created_at: string;
+  };
+}
+
+const db = new DriftClient<Database>({
+  driver: 'libsql',
+  auth: {
+    url: 'libsql://',
+    token: 'your-token',
+  },
+});
+```
+
+Now you can query your database with a developer-friendly api inspired by Prisma.
+
+```ts
+// Find all users
+// in every find method, you can pass a where object to filter the results
+const users = await db.findMany({ table: 'users' });
+
+// Find a single user
+const user = await db.findOne({ table: 'users', id: 1 });
+
+// Find the first user
+const user = await db.findFirst({ table: 'users', where: { id: 1 } });
+
+// Create a new user
+const user = await db.create({ table: 'users', data: { name: 'John Doe', email: 'john@doe.com', password: 'password' } });
+
+// Update a user
+const user = await db.update({ table: 'users', where: { id: 1 }, data: { name: 'John Doe' } });
+
+// Delete a user
+const user = await db.delete({ table: 'users', where: { id: 1 } });
+
+// Delete many users
+const users = await db.deleteMany({ table: 'users', where: { id: [1, 2, 3] } });
+```
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { type ResultSet } from '@libsql/client';
+declare const optionsSchema: z.ZodObject<{
+    driver: z.ZodEnum<["libsql"]>;
+    auth: z.ZodObject<{
+        url: z.ZodString;
+        token: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        token?: string | undefined;
+    }, {
+        url: string;
+        token?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    driver: "libsql";
+    auth: {
+        url: string;
+        token?: string | undefined;
+    };
+}, {
+    driver: "libsql";
+    auth: {
+        url: string;
+        token?: string | undefined;
+    };
+}>;
+type Options = z.infer<typeof optionsSchema>;
+export declare class DriftClient<T extends Record<string, any>> {
+    private url;
+    private token?;
+    private driver;
+    private libsqlClient?;
+    constructor(options: Options);
+    findMany<K extends keyof T>({ table, where, limit }: {
+        table: K;
+        where?: Partial<T[K]>;
+        limit?: number;
+    }): Promise<T[K][] | undefined>;
+    findOne<K extends keyof T>({ table, id }: {
+        table: K;
+        id: any;
+    }): Promise<T[K] | undefined>;
+    findFirst<K extends keyof T>({ table, where }: {
+        table: K;
+        where: Partial<T[K]>;
+    }): Promise<T[K] | undefined>;
+    create<K extends keyof T>({ table, data }: {
+        table: K;
+        data: Partial<T[K]>;
+    }): Promise<T[K] | undefined>;
+    update<K extends keyof T>({ table, where, data }: {
+        table: K;
+        where: Partial<T[K]>;
+        data: Partial<T[K]>;
+    }): Promise<T[K] | undefined>;
+    delete<K extends keyof T>({ table, where }: {
+        table: K;
+        where: Partial<T[K]>;
+    }): Promise<T[K] | undefined>;
+    deleteMany<K extends keyof T>({ table, where }: {
+        table: K;
+        where: Partial<T[K]>;
+    }): Promise<T[K] | undefined>;
+    sql(strings: TemplateStringsArray, ...values: any[]): Promise<ResultSet | undefined>;
+    private sanitizeValue;
+}
+export {};

package/dist/functions/create.d.ts

@@ -0,0 +1,6 @@
+import type { Client } from '@libsql/client';
+export declare function createLibsql({ table, data, libsqlClient }: {
+    table: any;
+    data: any;
+    libsqlClient: Client;
+}): Promise<Partial<import("@libsql/client").Row>>;

package/dist/functions/delete.d.ts

@@ -0,0 +1,5 @@
+export declare const deleteLibsql: ({ table, where, libsqlClient }: {
+    table: any;
+    where: any;
+    libsqlClient: any;
+}) => Promise<Partial<Record<string, any>>>;

package/dist/functions/deleteMany.d.ts

@@ -0,0 +1,5 @@
+export declare const deleteManyLibsql: ({ table, where, libsqlClient }: {
+    table: any;
+    where: any;
+    libsqlClient: any;
+}) => Promise<Partial<Record<string, any>>[]>;

package/dist/functions/findFirst.d.ts

@@ -0,0 +1,5 @@
+export declare const findFirstLibsql: ({ table, where, libsqlClient }: {
+    table: any;
+    where: any;
+    libsqlClient: any;
+}) => Promise<Partial<Record<string, any>>>;

package/dist/functions/findMany.d.ts

@@ -0,0 +1,7 @@
+import type { Client } from '@libsql/client';
+export declare const findManyLibsql: ({ table, where, limit, libsqlClient }: {
+    table: any;
+    where?: any;
+    limit?: number;
+    libsqlClient: Client;
+}) => Promise<Partial<import("@libsql/client").Row>[]>;

package/dist/functions/findOne.d.ts

@@ -0,0 +1,5 @@
+export declare const findOneLibsql: ({ table, id, libsqlClient }: {
+    table: any;
+    id: any;
+    libsqlClient: any;
+}) => Promise<Partial<Record<string, any>>>;

package/dist/functions/update.d.ts

@@ -0,0 +1,6 @@
+export declare const updateLibsql: ({ table, where, data, libsqlClient }: {
+    table: any;
+    where: any;
+    data: any;
+    libsqlClient: any;
+}) => Promise<Partial<Record<string, any>>>;

package/dist/lib/clean.d.ts

@@ -0,0 +1 @@
+export declare const cleanSqlRows: <T extends Record<string, any>>(rows: T[]) => Partial<T>[];

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+import { DriftClient } from './client';
+export { DriftClient };