@astrojs/db 0.7.0 → 0.7.2

package/dist/core/cli/commands/push/index.js

@@ -18,7 +18,7 @@ async function cmd({
   const appToken = await getManagedAppTokenOrExit(flags.token);
   const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
   const currentSnapshot = createCurrentSnapshot(dbConfig);
-  const isFromScratch = isForceReset || JSON.stringify(productionSnapshot) === "{}";
+  const isFromScratch = isForceReset || !productionSnapshot;
   const { queries: migrationQueries, confirmations } = await getMigrationQueries({
     oldSnapshot: isFromScratch ? createEmptySnapshot() : productionSnapshot,
     newSnapshot: currentSnapshot
@@ -64,13 +64,24 @@ async function pushSchema({
     return new Response(null, { status: 200 });
   }
   const url = new URL("/db/push", getRemoteDatabaseUrl());
-  return await fetch(url, {
+  const response = await fetch(url, {
     method: "POST",
     headers: new Headers({
       Authorization: `Bearer ${appToken}`
     }),
     body: JSON.stringify(requestBody)
   });
+  if (!response.ok) {
+    console.error(`${url.toString()} failed: ${response.status} ${response.statusText}`);
+    console.error(await response.text());
+    throw new Error(`/db/push fetch failed: ${response.status} ${response.statusText}`);
+  }
+  const result = await response.json();
+  if (!result.success) {
+    console.error(`${url.toString()} unsuccessful`);
+    console.error(await response.text());
+    throw new Error(`/db/push fetch unsuccessful`);
+  }
 }
 export {
   cmd

package/dist/core/cli/commands/verify/index.js

@@ -15,7 +15,7 @@ async function cmd({
   const productionSnapshot = await getProductionCurrentSnapshot({ appToken: appToken.token });
   const currentSnapshot = createCurrentSnapshot(dbConfig);
   const { queries: migrationQueries, confirmations } = await getMigrationQueries({
-    oldSnapshot: JSON.stringify(productionSnapshot) !== "{}" ? productionSnapshot : createEmptySnapshot(),
+    oldSnapshot: productionSnapshot || createEmptySnapshot(),
     newSnapshot: currentSnapshot
   });
   const result = { exitCode: 0, message: "", code: "", data: void 0 };

package/dist/core/cli/index.js

@@ -1,4 +1,5 @@
 import { resolveDbConfig } from "../load-file.js";
+import { printHelp } from "./print-help.js";
 async function cli({
   flags,
   config: astroConfig
@@ -44,31 +45,31 @@ async function cli({
       return await cmd();
     }
     default: {
-      if (command == null) {
-        console.error(`No command provided.
-
-${showHelp()}`);
-      } else {
-        console.error(`Unknown command: ${command}
-
-${showHelp()}`);
+      if (command != null) {
+        console.error(`Unknown command: ${command}`);
       }
+      printHelp({
+        commandName: "astro db",
+        usage: "[command] [...flags]",
+        headline: " ",
+        tables: {
+          Commands: [
+            ["push", "Push table schema updates to Astro Studio."],
+            ["verify", "Test schema updates /w Astro Studio (good for CI)."],
+            [
+              "astro db execute <file-path>",
+              "Execute a ts/js file using astro:db. Use --remote to connect to Studio."
+            ],
+            [
+              "astro db shell --query <sql-string>",
+              "Execute a SQL string. Use --remote to connect to Studio."
+            ]
+          ]
+        }
+      });
       return;
     }
   }
-  function showHelp() {
-    return `astro db <command>
-		
-Usage:
-
-astro login          Authenticate your machine with Astro Studio
-astro logout         End your authenticated session with Astro Studio
-astro link           Link this directory to an Astro Studio project
-
-astro db gen         Creates snapshot based on your schema
-astro db push        Pushes schema updates to Astro Studio
-astro db verify      Tests schema updates /w Astro Studio (good for CI)`;
-  }
 }
 export {
   cli

package/dist/core/cli/migration-queries.d.ts

@@ -16,7 +16,7 @@ export declare function getCollectionChangeQueries({ collectionName, oldCollecti
 }>;
 export declare function getProductionCurrentSnapshot({ appToken, }: {
     appToken: string;
-}): Promise<DBSnapshot>;
+}): Promise<DBSnapshot | undefined>;
 export declare function createCurrentSnapshot({ tables }: DBConfig): DBSnapshot;
 export declare function createEmptySnapshot(): DBSnapshot;
 export declare function formatDataLossMessage(confirmations: string[], isColor?: boolean): string;

package/dist/core/cli/migration-queries.js

@@ -331,7 +331,17 @@ async function getProductionCurrentSnapshot({
       Authorization: `Bearer ${appToken}`
     })
   });
+  if (!response.ok) {
+    console.error(`${url.toString()} failed: ${response.status} ${response.statusText}`);
+    console.error(await response.text());
+    throw new Error(`/db/schema fetch failed: ${response.status} ${response.statusText}`);
+  }
   const result = await response.json();
+  if (!result.success) {
+    console.error(`${url.toString()} unsuccessful`);
+    console.error(await response.text());
+    throw new Error(`/db/schema fetch unsuccessful`);
+  }
   return result.data;
 }
 function createCurrentSnapshot({ tables = {} }) {

package/dist/core/cli/print-help.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Uses implementation from Astro core
+ * @see https://github.com/withastro/astro/blob/main/packages/astro/src/core/messages.ts#L303
+ */
+export declare function printHelp({ commandName, headline, usage, tables, description, }: {
+    commandName: string;
+    headline?: string;
+    usage?: string;
+    tables?: Record<string, [command: string, help: string][]>;
+    description?: string;
+}): void;

package/dist/core/cli/print-help.js

@@ -0,0 +1,55 @@
+import { bgGreen, bgWhite, black, bold, dim, green } from "kleur/colors";
+function printHelp({
+  commandName,
+  headline,
+  usage,
+  tables,
+  description
+}) {
+  const linebreak = () => "";
+  const title = (label) => `  ${bgWhite(black(` ${label} `))}`;
+  const table = (rows, { padding }) => {
+    const split = process.stdout.columns < 60;
+    let raw = "";
+    for (const row of rows) {
+      if (split) {
+        raw += `    ${row[0]}
+    `;
+      } else {
+        raw += `${`${row[0]}`.padStart(padding)}`;
+      }
+      raw += "  " + dim(row[1]) + "\n";
+    }
+    return raw.slice(0, -1);
+  };
+  let message = [];
+  if (headline) {
+    message.push(
+      linebreak(),
+      `  ${bgGreen(black(` ${commandName} `))} ${green(
+        `v${"0.7.2"}`
+      )} ${headline}`
+    );
+  }
+  if (usage) {
+    message.push(linebreak(), `  ${green(commandName)} ${bold(usage)}`);
+  }
+  if (tables) {
+    let calculateTablePadding2 = function(rows) {
+      return rows.reduce((val, [first]) => Math.max(val, first.length), 0) + 2;
+    };
+    var calculateTablePadding = calculateTablePadding2;
+    const tableEntries = Object.entries(tables);
+    const padding = Math.max(...tableEntries.map(([, rows]) => calculateTablePadding2(rows)));
+    for (const [tableTitle, tableRows] of tableEntries) {
+      message.push(linebreak(), title(tableTitle), table(tableRows, { padding }));
+    }
+  }
+  if (description) {
+    message.push(linebreak(), `${description}`);
+  }
+  console.log(message.join("\n") + "\n");
+}
+export {
+  printHelp
+};

package/dist/core/consts.d.ts

@@ -3,6 +3,6 @@ export declare const RUNTIME_IMPORT: string;
 export declare const RUNTIME_CONFIG_IMPORT: string;
 export declare const DB_TYPES_FILE = "db-types.d.ts";
 export declare const VIRTUAL_MODULE_ID = "astro:db";
-export declare const DB_PATH: string;
+export declare const DB_PATH = ".astro/content.db";
 export declare const CONFIG_FILE_NAMES: string[];
 export declare const MIGRATION_VERSION = "2024-03-12";

package/dist/core/consts.js

@@ -1,13 +1,12 @@
-import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 const PACKAGE_NAME = JSON.parse(
   readFileSync(new URL("../../package.json", import.meta.url), "utf8")
 ).name;
 const RUNTIME_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime`);
-const RUNTIME_CONFIG_IMPORT = JSON.stringify(`${PACKAGE_NAME}/runtime/config`);
+const RUNTIME_CONFIG_IMPORT = JSON.stringify(`${PACKAGE_NAME}/dist/runtime/config.js`);
 const DB_TYPES_FILE = "db-types.d.ts";
 const VIRTUAL_MODULE_ID = "astro:db";
-const DB_PATH = `.astro/${process.env.ASTRO_TEST_RANDOM_DB_ID ? randomUUID() : "content.db"}`;
+const DB_PATH = ".astro/content.db";
 const CONFIG_FILE_NAMES = ["config.ts", "config.js", "config.mts", "config.mjs"];
 const MIGRATION_VERSION = "2024-03-12";
 export {

package/dist/core/integration/index.js

@@ -71,13 +71,10 @@ function astroDBIntegration() {
         tables.get = () => dbConfig.tables;
         seedFiles.get = () => integrationSeedPaths;
         configFileDependencies = dependencies;
-        if (!connectToStudio) {
-          const dbUrl = new URL(DB_PATH, config.root);
-          if (existsSync(dbUrl)) {
-            await rm(dbUrl);
-          }
-          await mkdir(dirname(fileURLToPath(dbUrl)), { recursive: true });
-          await writeFile(dbUrl, "");
+        const localDbUrl = new URL(DB_PATH, config.root);
+        if (!connectToStudio && !existsSync(localDbUrl)) {
+          await mkdir(dirname(fileURLToPath(localDbUrl)), { recursive: true });
+          await writeFile(localDbUrl, "");
         }
         await typegen({ tables: tables.get() ?? {}, root: config.root });
       },

package/dist/core/integration/vite-plugin-db.js

@@ -1,14 +1,6 @@
-import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { sql } from "drizzle-orm";
-import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { normalizePath } from "vite";
-import { createLocalDatabaseClient } from "../../runtime/db-client.js";
-import {
-  SEED_DEV_FILE_NAME,
-  getCreateIndexQueries,
-  getCreateTableQuery
-} from "../../runtime/queries.js";
+import { SEED_DEV_FILE_NAME } from "../../runtime/queries.js";
 import { DB_PATH, RUNTIME_CONFIG_IMPORT, RUNTIME_IMPORT, VIRTUAL_MODULE_ID } from "../consts.js";
 import { getDbDirectoryUrl, getRemoteDatabaseUrl } from "../utils.js";
 const WITH_SEED_VIRTUAL_MODULE_ID = "astro:db:seed";
@@ -18,9 +10,6 @@ const resolved = {
 };
 function vitePluginDb(params) {
   const srcDirPath = normalizePath(fileURLToPath(params.srcDir));
-  const seedFilePaths = SEED_DEV_FILE_NAME.map(
-    (name) => normalizePath(fileURLToPath(new URL(name, getDbDirectoryUrl(params.root))))
-  );
   return {
     name: "astro:db",
     enforce: "pre",
@@ -38,12 +27,6 @@ function vitePluginDb(params) {
       return resolved.virtual;
     },
     async load(id) {
-      if (seedFilePaths.some((f) => id === f)) {
-        await recreateTables({
-          db: createLocalDatabaseClient({ dbUrl: new URL(DB_PATH, params.root).href }),
-          tables: params.tables.get()
-        });
-      }
       if (id !== resolved.virtual && id !== resolved.seedVirtual)
         return;
       if (params.connectToStudio) {
@@ -75,24 +58,29 @@ function getLocalVirtualModContents({
     // for Vite import.meta.glob
     (name) => new URL(name, getDbDirectoryUrl("file:///")).pathname
   );
-  const resolveId = (id) => id.startsWith(".") ? resolve(fileURLToPath(root), id) : id;
-  const integrationSeedFilePaths = seedFiles.map(
-    (pathOrUrl) => typeof pathOrUrl === "string" ? resolveId(pathOrUrl) : pathOrUrl.pathname
-  );
-  const integrationSeedImports = integrationSeedFilePaths.map(
-    (filePath) => `() => import(${JSON.stringify(filePath)})`
-  );
+  const resolveId = (id) => id.startsWith(".") ? normalizePath(fileURLToPath(new URL(id, root))) : id;
+  const integrationSeedImportStatements = [];
+  const integrationSeedImportNames = [];
+  seedFiles.forEach((pathOrUrl, index) => {
+    const path = typeof pathOrUrl === "string" ? resolveId(pathOrUrl) : pathOrUrl.pathname;
+    const importName = "integration_seed_" + index;
+    integrationSeedImportStatements.push(`import ${importName} from ${JSON.stringify(path)};`);
+    integrationSeedImportNames.push(importName);
+  });
   const dbUrl = new URL(DB_PATH, root);
   return `
 import { asDrizzleTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
 ${shouldSeed ? `import { seedLocal } from ${RUNTIME_IMPORT};` : ""}
+${shouldSeed ? integrationSeedImportStatements.join("\n") : ""}
 
 const dbUrl = ${JSON.stringify(dbUrl)};
 export const db = createLocalDatabaseClient({ dbUrl });
 
 ${shouldSeed ? `await seedLocal({
+	db,
+	tables: ${JSON.stringify(tables)},
 	userSeedGlob: import.meta.glob(${JSON.stringify(userSeedFilePaths)}, { eager: true }),
-	integrationSeedImports: [${integrationSeedImports.join(",")}],
+	integrationSeedFunctions: [${integrationSeedImportNames.join(",")}],
 });` : ""}
 
 export * from ${RUNTIME_CONFIG_IMPORT};
@@ -123,20 +111,6 @@ function getStringifiedCollectionExports(tables) {
     )}, false)`
   ).join("\n");
 }
-const sqlite = new SQLiteAsyncDialect();
-async function recreateTables({ db, tables }) {
-  const setupQueries = [];
-  for (const [name, table] of Object.entries(tables)) {
-    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
-    const createQuery = sql.raw(getCreateTableQuery(name, table));
-    const indexQueries = getCreateIndexQueries(name, table);
-    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
-  }
-  await db.batch([
-    db.run(sql`pragma defer_foreign_keys=true;`),
-    ...setupQueries.map((q) => db.run(q))
-  ]);
-}
 export {
   getConfigVirtualModContents,
   getLocalVirtualModContents,

package/dist/runtime/index.d.ts

@@ -5,14 +5,7 @@ export { sql };
 export type SqliteDB = LibSQLDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
-export declare function seedLocal({ userSeedGlob, integrationSeedImports, }: {
-    userSeedGlob: Record<string, {
-        default?: () => Promise<void>;
-    }>;
-    integrationSeedImports: Array<() => Promise<{
-        default: () => Promise<void>;
-    }>>;
-}): Promise<void>;
+export { seedLocal } from './seed-local.js';
 export declare function hasPrimaryKey(column: DBColumn): boolean;
 export declare const NOW: import("drizzle-orm").SQL<unknown>;
 export declare const TRUE: import("drizzle-orm").SQL<unknown>;

package/dist/runtime/index.js

@@ -1,4 +1,3 @@
-import { LibsqlError } from "@libsql/client";
 import { sql } from "drizzle-orm";
 import {
   customType,
@@ -7,40 +6,10 @@ import {
   sqliteTable,
   text
 } from "drizzle-orm/sqlite-core";
-import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "../core/errors.js";
 import {} from "../core/types.js";
 import { isSerializedSQL } from "./types.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
-async function seedLocal({
-  // Glob all potential seed files to catch renames and deletions.
-  userSeedGlob,
-  integrationSeedImports
-}) {
-  const seedFilePath = Object.keys(userSeedGlob)[0];
-  if (seedFilePath) {
-    const mod = userSeedGlob[seedFilePath];
-    if (!mod.default) {
-      throw new Error(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
-    }
-    try {
-      await mod.default();
-    } catch (e) {
-      if (e instanceof LibsqlError) {
-        throw new Error(SEED_ERROR(e.message));
-      }
-      throw e;
-    }
-  }
-  for (const importModule of integrationSeedImports) {
-    const mod = await importModule();
-    await mod.default().catch((e) => {
-      if (e instanceof LibsqlError) {
-        throw new Error(SEED_ERROR(e.message));
-      }
-      throw e;
-    });
-  }
-}
+import { seedLocal } from "./seed-local.js";
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }

package/dist/runtime/seed-local.d.ts

@@ -0,0 +1,10 @@
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type DBTables } from '../core/types.js';
+export declare function seedLocal({ db, tables, userSeedGlob, integrationSeedFunctions, }: {
+    db: LibSQLDatabase;
+    tables: DBTables;
+    userSeedGlob: Record<string, {
+        default?: () => Promise<void>;
+    }>;
+    integrationSeedFunctions: Array<() => Promise<void>>;
+}): Promise<void>;

package/dist/runtime/seed-local.js

@@ -0,0 +1,53 @@
+import { LibsqlError } from "@libsql/client";
+import { sql } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { SEED_DEFAULT_EXPORT_ERROR, SEED_ERROR } from "../core/errors.js";
+import {} from "../core/types.js";
+import { getCreateIndexQueries, getCreateTableQuery } from "./queries.js";
+const sqlite = new SQLiteAsyncDialect();
+async function seedLocal({
+  db,
+  tables,
+  // Glob all potential seed files to catch renames and deletions.
+  userSeedGlob,
+  integrationSeedFunctions
+}) {
+  await recreateTables({ db, tables });
+  const seedFunctions = [];
+  const seedFilePath = Object.keys(userSeedGlob)[0];
+  if (seedFilePath) {
+    const mod = userSeedGlob[seedFilePath];
+    if (!mod.default)
+      throw new Error(SEED_DEFAULT_EXPORT_ERROR(seedFilePath));
+    seedFunctions.push(mod.default);
+  }
+  for (const seedFn of integrationSeedFunctions) {
+    seedFunctions.push(seedFn);
+  }
+  for (const seed of seedFunctions) {
+    try {
+      await seed();
+    } catch (e) {
+      if (e instanceof LibsqlError) {
+        throw new Error(SEED_ERROR(e.message));
+      }
+      throw e;
+    }
+  }
+}
+async function recreateTables({ db, tables }) {
+  const setupQueries = [];
+  for (const [name, table] of Object.entries(tables)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
+    const createQuery = sql.raw(getCreateTableQuery(name, table));
+    const indexQueries = getCreateIndexQueries(name, table);
+    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
+  }
+  await db.batch([
+    db.run(sql`pragma defer_foreign_keys=true;`),
+    ...setupQueries.map((q) => db.run(q))
+  ]);
+}
+export {
+  seedLocal
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -20,8 +20,7 @@
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
     },
-    "./runtime/config": {
-      "types": "./dist/runtime/config.d.ts",
+    "./dist/runtime/config.js": {
       "import": "./dist/runtime/config.js"
     },
     "./package.json": "./package.json"
@@ -36,9 +35,6 @@
       ],
       "runtime": [
         "./dist/runtime/index.d.ts"
-      ],
-      "runtime/config": [
-        "./dist/runtime/config.d.ts"
       ]
     }
   },
@@ -52,7 +48,7 @@
     "astro-integration"
   ],
   "dependencies": {
-    "@libsql/client": "^0.4.3",
+    "@libsql/client": "^0.5.5",
     "async-listen": "^3.0.1",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.29.5",
@@ -77,7 +73,7 @@
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
     "vite": "^5.1.4",
-    "astro": "4.4.15",
+    "astro": "4.5.1",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

package/dist/runtime/config.d.ts

@@ -1,148 +0,0 @@
-import type { ColumnsConfig, DBConfigInput, TableConfig } from '../core/types.js';
-export declare const column: {
-    number: <T extends ({
-        name?: string | undefined;
-        label?: string | undefined;
-        unique?: boolean | undefined;
-        deprecated?: boolean | undefined;
-        collection?: string | undefined;
-    } & ({
-        primaryKey?: false | undefined;
-        optional?: boolean | undefined;
-        default?: number | import("drizzle-orm").SQL<any> | undefined;
-    } | {
-        primaryKey: true;
-        optional?: false | undefined;
-        default?: undefined;
-    })) & {
-        references?: (() => {
-            type: "number";
-            schema: ({
-                name?: string | undefined;
-                label?: string | undefined;
-                unique?: boolean | undefined;
-                deprecated?: boolean | undefined;
-                collection?: string | undefined;
-            } & {
-                primaryKey?: false | undefined;
-                optional?: boolean | undefined;
-                default?: number | import("drizzle-orm").SQL<any> | undefined;
-            } & any) | ({
-                name?: string | undefined;
-                label?: string | undefined;
-                unique?: boolean | undefined;
-                deprecated?: boolean | undefined;
-                collection?: string | undefined;
-            } & {
-                primaryKey: true;
-                optional?: false | undefined;
-                default?: undefined;
-            } & any);
-        }) | undefined;
-    }>(opts?: T) => {
-        type: "number";
-        /**
-         * @internal
-         */
-        schema: T;
-    };
-    boolean: <T_1 extends {
-        name?: string | undefined;
-        label?: string | undefined;
-        optional?: boolean | undefined;
-        unique?: boolean | undefined;
-        deprecated?: boolean | undefined;
-        collection?: string | undefined;
-        default?: boolean | import("drizzle-orm").SQL<any> | undefined;
-    }>(opts?: T_1) => {
-        type: "boolean";
-        /**
-         * @internal
-         */
-        schema: T_1;
-    };
-    text: <T_2 extends ({
-        name?: string | undefined;
-        label?: string | undefined;
-        unique?: boolean | undefined;
-        deprecated?: boolean | undefined;
-        collection?: string | undefined;
-        default?: string | import("drizzle-orm").SQL<any> | undefined;
-        multiline?: boolean | undefined;
-    } & ({
-        primaryKey?: false | undefined;
-        optional?: boolean | undefined;
-    } | {
-        primaryKey: true;
-        optional?: false | undefined;
-    })) & {
-        references?: (() => {
-            type: "text";
-            schema: ({
-                name?: string | undefined;
-                label?: string | undefined;
-                unique?: boolean | undefined;
-                deprecated?: boolean | undefined;
-                collection?: string | undefined;
-                default?: string | import("drizzle-orm").SQL<any> | undefined;
-                multiline?: boolean | undefined;
-            } & {
-                primaryKey?: false | undefined;
-                optional?: boolean | undefined;
-            } & any) | ({
-                name?: string | undefined;
-                label?: string | undefined;
-                unique?: boolean | undefined;
-                deprecated?: boolean | undefined;
-                collection?: string | undefined;
-                default?: string | import("drizzle-orm").SQL<any> | undefined;
-                multiline?: boolean | undefined;
-            } & {
-                primaryKey: true;
-                optional?: false | undefined;
-            } & any);
-        }) | undefined;
-    }>(opts?: T_2) => {
-        type: "text";
-        /**
-         * @internal
-         */
-        schema: T_2;
-    };
-    date<T_3 extends {
-        name?: string | undefined;
-        label?: string | undefined;
-        optional?: boolean | undefined;
-        unique?: boolean | undefined;
-        deprecated?: boolean | undefined;
-        collection?: string | undefined;
-        default?: Date | import("drizzle-orm").SQL<any> | undefined;
-    }>(opts?: T_3): {
-        type: "date";
-        /**
-         * @internal
-         */
-        schema: T_3;
-    };
-    json<T_4 extends {
-        name?: string | undefined;
-        label?: string | undefined;
-        optional?: boolean | undefined;
-        unique?: boolean | undefined;
-        deprecated?: boolean | undefined;
-        collection?: string | undefined;
-        default?: unknown;
-    }>(opts?: T_4): {
-        type: "json";
-        /**
-         * @internal
-         */
-        schema: T_4;
-    };
-};
-export declare function defineTable<TColumns extends ColumnsConfig>(userConfig: TableConfig<TColumns>): TableConfig<TColumns>;
-export declare function defineDb(userConfig: DBConfigInput): {
-    tables?: unknown;
-};
-export { NOW, TRUE, FALSE } from './index.js';
-export { sql, eq, gt, gte, lt, lte, ne, isNull, isNotNull, inArray, notInArray, exists, notExists, between, notBetween, like, notIlike, not, asc, desc, and, or, } from 'drizzle-orm';