rado 0.1.0 → 0.1.2

package/dist/Driver.d.ts

@@ -10,66 +10,78 @@ declare class Callable extends Function {
 declare abstract class DriverBase extends Callable {
     formatter: Formatter;
     constructor(formatter: Formatter);
-    all(strings: TemplateStringsArray, ...params: Array<any>): any;
-    get(strings: TemplateStringsArray, ...params: Array<any>): any;
+    all(...args: Array<any>): any;
+    get(...args: Array<any>): any;
+    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
     executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
     abstract executeQuery(query: Query<any>): any;
 }
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: number;
+    abstract rows(stmt: Statement.Compiled): Array<object>;
+    abstract values(stmt: Statement.Compiled): Array<Array<any>>;
+    abstract execute(stmt: Statement.Compiled): void;
+    abstract mutate(stmt: Statement.Compiled): {
+        rowsAffected: number;
+    };
+    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    migrateSchema(...tables: Array<Table<any>>): unknown;
+    executeQuery<T>(query: Query<T>): T;
+    all<T>(cursor: Cursor<T>): Array<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
+    get<T>(cursor: Cursor<T>): T;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    transaction<T>(run: (query: SyncDriver) => T): T;
+    toAsync(): SyncWrapper;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
+    abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+    abstract execute(stmt: Statement.Compiled): Promise<void>;
+    abstract mutate(stmt: Statement.Compiled): Promise<{
+        rowsAffected: number;
+    }>;
+    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    all<T>(cursor: Cursor<T>): Promise<Array<T>>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
+    get<T>(cursor: Cursor<T>): Promise<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    executeQuery<T>(query: Query<T>): Promise<T>;
+    rows(stmt: Statement.Compiled): Promise<Array<object>>;
+    values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
+    execute(stmt: Statement.Compiled): Promise<void>;
+    mutate(stmt: Statement.Compiled): Promise<{
+        rowsAffected: number;
+    }>;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
 export declare namespace Driver {
-    export interface Sync {
-        <T>(query: Cursor<T>): T;
-        (strings: TemplateStringsArray, ...values: any[]): any;
-    }
-    export abstract class Sync extends DriverBase {
-        transactionId: number;
-        abstract rows(stmt: Statement.Compiled): Array<object>;
-        abstract values(stmt: Statement.Compiled): Array<Array<any>>;
-        abstract execute(stmt: Statement.Compiled): void;
-        abstract mutate(stmt: Statement.Compiled): {
-            rowsAffected: number;
-        };
-        abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
-        migrateSchema(...tables: Array<Table<any>>): unknown;
-        executeQuery<T>(query: Query<T>): T;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-        transaction<T>(run: (query: Sync) => T): T;
-        toAsync(): SyncWrapper;
-    }
-    export interface Async {
-        <T>(query: Cursor<T>): Promise<T>;
-        (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-    }
-    export abstract class Async extends DriverBase {
-        transactionId: number;
-        abstract isolate(): [connection: Async, release: () => Promise<void>];
-        abstract rows(stmt: Statement.Compiled): Promise<Array<object>>;
-        abstract values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-        abstract execute(stmt: Statement.Compiled): Promise<void>;
-        abstract mutate(stmt: Statement.Compiled): Promise<{
-            rowsAffected: number;
-        }>;
-        abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-        migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-        get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-        transaction<T>(run: (query: Async) => T): Promise<T>;
-    }
-    class SyncWrapper extends Async {
-        private sync;
-        lock: Promise<void> | undefined;
-        constructor(sync: Sync);
-        executeQuery<T>(query: Query<T>): Promise<T>;
-        rows(stmt: Statement.Compiled): Promise<Array<object>>;
-        values(stmt: Statement.Compiled): Promise<Array<Array<any>>>;
-        execute(stmt: Statement.Compiled): Promise<void>;
-        mutate(stmt: Statement.Compiled): Promise<{
-            rowsAffected: number;
-        }>;
-        schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-        isolate(): [connection: Async, release: () => Promise<void>];
-    }
-    export {};
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
 }
 export {};

package/dist/Driver.js

@@ -12,232 +12,248 @@ var Callable = class extends Function {
     });
   }
 };
+function isTemplateStringsArray(input) {
+  return Boolean(Array.isArray(input) && input.raw);
+}
 var DriverBase = class extends Callable {
   constructor(formatter) {
     super((...args) => {
       const [input, ...rest] = args;
-      if (input instanceof Cursor)
+      if (input instanceof Cursor && rest.length === 0)
         return this.executeQuery(input.query());
-      return this.executeTemplate(void 0, input, ...rest);
+      if (isTemplateStringsArray(input))
+        return this.executeTemplate(void 0, input, ...rest);
+      return this.executeQuery(
+        Query.Batch({
+          queries: args.filter((arg) => arg instanceof Cursor).map((arg) => arg.query())
+        })
+      );
     });
     this.formatter = formatter;
   }
-  all(strings, ...params) {
-    return this.executeTemplate("rows", strings, ...params);
+  all(...args) {
+    const [input, ...rest] = args;
+    if (input instanceof Cursor)
+      return this.executeQuery(input.query());
+    return this.executeTemplate("rows", input, ...rest);
+  }
+  get(...args) {
+    const [input, ...rest] = args;
+    if (input instanceof Cursor.SelectMultiple)
+      return this.executeQuery(input.first().query());
+    if (input instanceof Cursor)
+      return this.executeQuery(input.query());
+    return this.executeTemplate("row", input, ...rest);
   }
-  get(strings, ...params) {
-    return this.executeTemplate("row", strings, ...params);
+  sql(strings, ...params) {
+    return new Cursor(Query.Raw({ strings, params }));
   }
   executeTemplate(expectedReturn, strings, ...params) {
-    if (strings.some((chunk) => chunk.includes("?")))
-      throw new TypeError("SQL injection hazard");
     return this.executeQuery(Query.Raw({ strings, params, expectedReturn }));
   }
 };
-var Driver;
-((Driver2) => {
-  class Sync extends DriverBase {
-    transactionId = 0;
-    migrateSchema(...tables) {
-      const queries = [];
-      for (const table of Object.values(tables)) {
-        const schema = table.schema();
-        const localSchema = this.schemaInstructions(schema.name);
-        if (!localSchema) {
-          queries.push(...Schema.create(schema).queries);
-        } else {
-          const changes = Schema.upgrade(this.formatter, localSchema, schema);
-          if (changes.length)
-            queries.push(...changes);
-        }
+var SyncDriver = class extends DriverBase {
+  transactionId = 0;
+  migrateSchema(...tables) {
+    const queries = [];
+    for (const table of Object.values(tables)) {
+      const schema = table.schema();
+      const localSchema = this.schemaInstructions(schema.name);
+      if (!localSchema) {
+        queries.push(...Schema.create(schema).queries);
+      } else {
+        const changes = Schema.upgrade(this.formatter, localSchema, schema);
+        if (changes.length)
+          queries.push(...changes);
       }
-      return this.executeQuery(Query.Batch({ queries }));
     }
-    executeQuery(query) {
-      switch (query.type) {
-        case QueryType.Batch:
-          let result;
-          const stmts = query.queries;
-          if (stmts.length === 0)
-            return void 0;
-          if (stmts.length === 1)
-            return this.executeQuery(stmts[0]);
-          return this.transaction((cnx) => {
-            for (const query2 of stmts)
-              result = cnx.executeQuery(query2);
-            return result;
-          });
-        default:
-          const stmt = this.formatter.compile(query);
-          if ("selection" in query) {
-            const res = this.values(stmt).map(
-              ([item]) => JSON.parse(item).result
-            );
-            if (query.singleResult)
-              return res[0];
-            return res;
-          } else if (query.type === QueryType.Raw) {
-            switch (query.expectedReturn) {
-              case "row":
-                return this.rows(stmt)[0];
-              case "rows":
-                return this.rows(stmt);
-              default:
-                this.execute(stmt);
-                return void 0;
-            }
-          } else {
-            return this.mutate(stmt);
+    return this.executeQuery(Query.Batch({ queries }));
+  }
+  executeQuery(query) {
+    switch (query.type) {
+      case QueryType.Batch:
+        let result;
+        const stmts = query.queries;
+        if (stmts.length === 0)
+          return void 0;
+        if (stmts.length === 1)
+          return this.executeQuery(stmts[0]);
+        return this.transaction((cnx) => {
+          for (const query2 of stmts)
+            result = cnx.executeQuery(query2);
+          return result;
+        });
+      default:
+        const stmt = this.formatter.compile(query);
+        if ("selection" in query) {
+          const res = this.values(stmt).map(([item]) => JSON.parse(item).result);
+          if (query.singleResult)
+            return res[0];
+          return res;
+        } else if (query.type === QueryType.Raw) {
+          switch (query.expectedReturn) {
+            case "row":
+              return this.rows(stmt)[0];
+            case "rows":
+              return this.rows(stmt);
+            default:
+              this.execute(stmt);
+              return void 0;
           }
-      }
-    }
-    all(strings, ...params) {
-      return super.all(strings, ...params);
-    }
-    get(strings, ...params) {
-      return super.get(strings, ...params);
+        } else {
+          return this.mutate(stmt);
+        }
     }
-    transaction(run) {
-      const id = `t${this.transactionId++}`;
+  }
+  all(...args) {
+    return super.all(...args);
+  }
+  get(...args) {
+    return super.get(...args);
+  }
+  transaction(run) {
+    const id = `t${this.transactionId++}`;
+    this.executeQuery(
+      Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+    );
+    try {
+      const res = run(this);
       this.executeQuery(
-        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+        Query.Transaction({ op: Query.TransactionOperation.Commit, id })
       );
-      try {
-        const res = run(this);
-        this.executeQuery(
-          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
-        );
-        return res;
-      } catch (e) {
-        this.executeQuery(
-          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
-        );
-        throw e;
-      }
-    }
-    toAsync() {
-      return new SyncWrapper(this);
+      return res;
+    } catch (e) {
+      this.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+      );
+      throw e;
     }
   }
-  Driver2.Sync = Sync;
-  class Async extends DriverBase {
-    transactionId = 0;
-    async migrateSchema(...tables) {
-      const queries = [];
-      for (const table of Object.values(tables)) {
-        const schema = table.schema();
-        const localSchema = await this.schemaInstructions(schema.name);
-        if (!localSchema) {
-          queries.push(...Schema.create(schema).queries);
-        } else {
-          const changes = Schema.upgrade(this.formatter, localSchema, schema);
-          if (changes.length)
-            queries.push(...changes);
-        }
+  toAsync() {
+    return new SyncWrapper(this);
+  }
+};
+var AsyncDriver = class extends DriverBase {
+  transactionId = 0;
+  async migrateSchema(...tables) {
+    const queries = [];
+    for (const table of Object.values(tables)) {
+      const schema = table.schema();
+      const localSchema = await this.schemaInstructions(schema.name);
+      if (!localSchema) {
+        queries.push(...Schema.create(schema).queries);
+      } else {
+        const changes = Schema.upgrade(this.formatter, localSchema, schema);
+        if (changes.length)
+          queries.push(...changes);
       }
-      return this.executeQuery(Query.Batch({ queries }));
     }
-    async executeQuery(query) {
-      switch (query.type) {
-        case QueryType.Batch:
-          let result;
-          const stmts = query.queries;
-          if (stmts.length === 0)
-            return void 0;
-          if (stmts.length === 1)
-            return this.executeQuery(stmts[0]);
-          return this.transaction(async (cnx) => {
-            for (const query2 of stmts)
-              result = await cnx.executeQuery(query2);
-            return result;
-          });
-        default:
-          const stmt = this.formatter.compile(query);
-          if ("selection" in query) {
-            const res = (await this.values(stmt)).map(
-              ([item]) => JSON.parse(item).result
-            );
-            if (query.singleResult)
-              return res[0];
-            return res;
-          } else if (query.type === QueryType.Raw) {
-            switch (query.expectedReturn) {
-              case "row":
-                return (await this.rows(stmt))[0];
-              case "rows":
-                return await this.rows(stmt);
-              default:
-                await this.execute(stmt);
-                return void 0;
-            }
-          } else {
-            return await this.mutate(stmt);
+    return this.executeQuery(Query.Batch({ queries }));
+  }
+  async executeQuery(query) {
+    switch (query.type) {
+      case QueryType.Batch:
+        let result;
+        const stmts = query.queries;
+        if (stmts.length === 0)
+          return void 0;
+        if (stmts.length === 1)
+          return this.executeQuery(stmts[0]);
+        return this.transaction(async (cnx) => {
+          for (const query2 of stmts)
+            result = await cnx.executeQuery(query2);
+          return result;
+        });
+      default:
+        const stmt = this.formatter.compile(query);
+        if ("selection" in query) {
+          const res = (await this.values(stmt)).map(
+            ([item]) => JSON.parse(item).result
+          );
+          if (query.singleResult)
+            return res[0];
+          return res;
+        } else if (query.type === QueryType.Raw) {
+          switch (query.expectedReturn) {
+            case "row":
+              return (await this.rows(stmt))[0];
+            case "rows":
+              return await this.rows(stmt);
+            default:
+              await this.execute(stmt);
+              return void 0;
           }
-      }
-    }
-    all(strings, ...params) {
-      return super.all(strings, ...params);
-    }
-    get(strings, ...params) {
-      return super.get(strings, ...params);
+        } else {
+          return await this.mutate(stmt);
+        }
     }
-    async transaction(run) {
-      const id = `t${this.transactionId++}`;
-      const [connection, release] = this.isolate();
+  }
+  all(...args) {
+    return super.all(...args);
+  }
+  get(...args) {
+    return super.get(...args);
+  }
+  async transaction(run) {
+    const id = `t${this.transactionId++}`;
+    const [connection, release] = this.isolate();
+    await connection.executeQuery(
+      Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+    );
+    try {
+      const res = await run(connection);
       await connection.executeQuery(
-        Query.Transaction({ op: Query.TransactionOperation.Begin, id })
+        Query.Transaction({ op: Query.TransactionOperation.Commit, id })
       );
-      try {
-        const res = await run(connection);
-        await connection.executeQuery(
-          Query.Transaction({ op: Query.TransactionOperation.Commit, id })
-        );
-        return res;
-      } catch (e) {
-        await connection.executeQuery(
-          Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
-        );
-        throw e;
-      } finally {
-        await release();
-      }
+      return res;
+    } catch (e) {
+      await connection.executeQuery(
+        Query.Transaction({ op: Query.TransactionOperation.Rollback, id })
+      );
+      throw e;
+    } finally {
+      await release();
     }
   }
-  Driver2.Async = Async;
-  class SyncWrapper extends Async {
-    constructor(sync) {
-      super(sync.formatter);
-      this.sync = sync;
-    }
-    lock;
-    async executeQuery(query) {
-      await this.lock;
-      return super.executeQuery(query);
-    }
-    async rows(stmt) {
-      return this.sync.rows(stmt);
-    }
-    async values(stmt) {
-      return this.sync.values(stmt);
-    }
-    async execute(stmt) {
-      return this.sync.execute(stmt);
-    }
-    async mutate(stmt) {
-      return this.sync.mutate(stmt);
-    }
-    async schemaInstructions(tableName) {
-      return this.sync.schemaInstructions(tableName);
-    }
-    isolate() {
-      const connection = new SyncWrapper(this.sync);
-      let release, trigger = new Promise((resolve) => {
-        release = async () => resolve();
-      });
-      this.lock = Promise.resolve(this.lock).then(() => trigger);
-      return [connection, release];
-    }
+};
+var SyncWrapper = class extends AsyncDriver {
+  constructor(sync) {
+    super(sync.formatter);
+    this.sync = sync;
+  }
+  lock;
+  async executeQuery(query) {
+    await this.lock;
+    return super.executeQuery(query);
+  }
+  async rows(stmt) {
+    return this.sync.rows(stmt);
+  }
+  async values(stmt) {
+    return this.sync.values(stmt);
+  }
+  async execute(stmt) {
+    return this.sync.execute(stmt);
+  }
+  async mutate(stmt) {
+    return this.sync.mutate(stmt);
   }
+  async schemaInstructions(tableName) {
+    return this.sync.schemaInstructions(tableName);
+  }
+  isolate() {
+    const connection = new SyncWrapper(this.sync);
+    let release, trigger = new Promise((resolve) => {
+      release = async () => resolve();
+    });
+    this.lock = Promise.resolve(this.lock).then(() => trigger);
+    return [connection, release];
+  }
+};
+var Driver;
+((Driver2) => {
+  Driver2.Sync = SyncDriver;
+  Driver2.Async = AsyncDriver;
 })(Driver || (Driver = {}));
 export {
   Driver

package/dist/Query.js

@@ -58,6 +58,8 @@ var Query;
   }
   Query2.Transaction = Transaction;
   function Raw(raw) {
+    if (raw.strings.some((chunk) => chunk.includes("?")))
+      throw new TypeError("SQL injection hazard");
     return { type: "Raw" /* Raw */, ...raw };
   }
   Query2.Raw = Raw;

package/dist/driver/better-sqlite3.js

@@ -21,17 +21,13 @@ var BetterSqlite3Driver = class extends Driver.Sync {
     return { rowsAffected: changes };
   }
   schemaInstructions(tableName) {
-    try {
-      const columnData = this.rows(
-        SqliteSchema.tableData(tableName).compile(this.formatter)
-      );
-      const indexData = this.rows(
-        SqliteSchema.indexData(tableName).compile(this.formatter)
-      );
-      return SqliteSchema.createInstructions(columnData, indexData);
-    } catch (e) {
-      return void 0;
-    }
+    const columnData = this.rows(
+      SqliteSchema.tableData(tableName).compile(this.formatter)
+    );
+    const indexData = this.rows(
+      SqliteSchema.indexData(tableName).compile(this.formatter)
+    );
+    return SqliteSchema.createInstructions(columnData, indexData);
   }
   export() {
     return this.db.serialize();

package/dist/driver/sql.js.js

@@ -31,17 +31,13 @@ var SqlJsDriver = class extends Driver.Sync {
     return { rowsAffected: this.db.getRowsModified() };
   }
   schemaInstructions(tableName) {
-    try {
-      const columnData = this.rows(
-        SqliteSchema.tableData(tableName).compile(this.formatter)
-      );
-      const indexData = this.rows(
-        SqliteSchema.indexData(tableName).compile(this.formatter)
-      );
-      return SqliteSchema.createInstructions(columnData, indexData);
-    } catch (e) {
-      return void 0;
-    }
+    const columnData = this.rows(
+      SqliteSchema.tableData(tableName).compile(this.formatter)
+    );
+    const indexData = this.rows(
+      SqliteSchema.indexData(tableName).compile(this.formatter)
+    );
+    return SqliteSchema.createInstructions(columnData, indexData);
   }
   export() {
     return this.db.export();

package/dist/driver/sqlite3.js

@@ -50,17 +50,13 @@ var Sqlite3Driver = class extends Driver.Async {
     });
   }
   async schemaInstructions(tableName) {
-    try {
-      const columnData = await this.rows(
-        SqliteSchema.tableData(tableName).compile(this.formatter)
-      );
-      const indexData = await this.rows(
-        SqliteSchema.indexData(tableName).compile(this.formatter)
-      );
-      return SqliteSchema.createInstructions(columnData, indexData);
-    } catch (e) {
-      return void 0;
-    }
+    const columnData = await this.rows(
+      SqliteSchema.tableData(tableName).compile(this.formatter)
+    );
+    const indexData = await this.rows(
+      SqliteSchema.indexData(tableName).compile(this.formatter)
+    );
+    return SqliteSchema.createInstructions(columnData, indexData);
   }
   isolate() {
     const connection = new Sqlite3Driver(this.db);

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './Column';
 export * from './Cursor';
+export * from './Driver';
 export * from './Expr';
 export * from './Fields';
 export * from './Formatter';
@@ -9,6 +10,7 @@ export * from './OrderBy';
 export * from './Param';
 export * from './Query';
 export * from './Sanitizer';
+export * from './Schema';
 export * from './Selection';
 export * from './Statement';
 export * from './Table';

package/dist/index.js

@@ -1,6 +1,7 @@
 // src/index.ts
 export * from "./Column.js";
 export * from "./Cursor.js";
+export * from "./Driver.js";
 export * from "./Expr.js";
 export * from "./Fields.js";
 export * from "./Formatter.js";
@@ -10,6 +11,7 @@ export * from "./OrderBy.js";
 export * from "./Param.js";
 export * from "./Query.js";
 export * from "./Sanitizer.js";
+export * from "./Schema.js";
 export * from "./Selection.js";
 export * from "./Statement.js";
 export * from "./Table.js";

package/dist/sqlite/SqliteSchema.d.ts

@@ -18,7 +18,7 @@ export declare namespace SqliteSchema {
     }
     function tableData(tableName: string): Statement;
     function indexData(tableName: string): Statement;
-    function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions;
+    function createInstructions(columnData: Array<Column>, indexData: Array<Index>): SchemaInstructions | undefined;
     function columnInstruction(column: Column): [string, string];
     function indexInstruction(index: Index): [string, string];
 }

package/dist/sqlite/SqliteSchema.js

@@ -13,6 +13,8 @@ var SqliteSchema;
   }
   SqliteSchema2.indexData = indexData;
   function createInstructions(columnData, indexData2) {
+    if (columnData.length === 0 && indexData2.length === 0)
+      return void 0;
     const columns = columnData.map(columnInstruction);
     const indexes = indexData2.map(indexInstruction);
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "license": "MIT",
   "type": "module",
   "exports": {