@astrojs/db 0.8.5 → 0.8.7

package/dist/_internal/runtime/config.d.ts

@@ -1,4 +1,5 @@
 import type { ColumnsConfig, DBConfigInput, TableConfig } from '../core/types.js';
+export type { LibSQLDatabase } from 'drizzle-orm/libsql';
 export declare const column: {
     number: <T extends ({
         name?: string | undefined;
@@ -144,5 +145,7 @@ export declare function defineTable<TColumns extends ColumnsConfig>(userConfig:
 export declare function defineDb(userConfig: DBConfigInput): {
     tables?: unknown;
 };
-export { NOW, TRUE, FALSE } from './index.js';
+export declare const NOW: import("drizzle-orm").SQL<unknown>;
+export declare const TRUE: import("drizzle-orm").SQL<unknown>;
+export declare const FALSE: import("drizzle-orm").SQL<unknown>;
 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';

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

@@ -1,8 +1,11 @@
 import { existsSync } from "node:fs";
+import { LibsqlError } from "@libsql/client";
+import { green } from "kleur/colors";
 import {
+  EXEC_DEFAULT_EXPORT_ERROR,
+  EXEC_ERROR,
   FILE_NOT_FOUND_ERROR,
-  MISSING_EXECUTE_PATH_ERROR,
-  SEED_DEFAULT_EXPORT_ERROR
+  MISSING_EXECUTE_PATH_ERROR
 } from "../../../errors.js";
 import {
   getLocalVirtualModContents,
@@ -44,10 +47,18 @@ async function cmd({
   const { code } = await bundleFile({ virtualModContents, root: astroConfig.root, fileUrl });
   const mod = await importBundledFile({ code, root: astroConfig.root });
   if (typeof mod.default !== "function") {
-    console.error(SEED_DEFAULT_EXPORT_ERROR);
+    console.error(EXEC_DEFAULT_EXPORT_ERROR);
     process.exit(1);
   }
-  await mod.default();
+  try {
+    await mod.default();
+    console.info(`${green("\u2714")} File run successfully.`);
+  } catch (e) {
+    if (e instanceof LibsqlError) {
+      throw new Error(EXEC_ERROR(e.message));
+    }
+    throw e;
+  }
 }
 export {
   cmd

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

@@ -27,7 +27,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"0.8.5"}`
+        `v${"0.8.7"}`
       )} ${headline}`
     );
   }

package/dist/core/errors.d.ts

@@ -6,7 +6,9 @@ export declare const RENAME_COLUMN_ERROR: (oldSelector: string, newSelector: str
 export declare const FILE_NOT_FOUND_ERROR: (path: string) => string;
 export declare const SHELL_QUERY_MISSING_ERROR: string;
 export declare const SEED_ERROR: (error: string) => string;
+export declare const EXEC_ERROR: (error: string) => string;
 export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;
+export declare const EXEC_DEFAULT_EXPORT_ERROR: (fileName: string) => string;
 export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
 export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
 export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;

package/dist/core/errors.js

@@ -34,10 +34,16 @@ const SEED_ERROR = (error) => {
 
 ${error}`;
 };
-const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
-  return red("Error while seeding database:") + `
+const EXEC_ERROR = (error) => {
+  return `${red(`Error while executing file:`)}
 
-Missing default function export in ${bold(fileName)}`;
+${error}`;
+};
+const SEED_DEFAULT_EXPORT_ERROR = (fileName) => {
+  return SEED_ERROR(`Missing default function export in ${bold(fileName)}`);
+};
+const EXEC_DEFAULT_EXPORT_ERROR = (fileName) => {
+  return EXEC_ERROR(`Missing default function export in ${bold(fileName)}`);
 };
 const REFERENCE_DNE_ERROR = (columnName) => {
   return `Column ${bold(
@@ -65,6 +71,8 @@ const INTEGRATION_TABLE_CONFLICT_ERROR = (integrationName, tableName, isUserConf
   Another integration already added a table named ${bold(tableName)}`;
 };
 export {
+  EXEC_DEFAULT_EXPORT_ERROR,
+  EXEC_ERROR,
   FILE_NOT_FOUND_ERROR,
   FOREIGN_KEY_DNE_ERROR,
   FOREIGN_KEY_REFERENCES_EMPTY_ERROR,

package/dist/core/integration/index.js

@@ -1,7 +1,7 @@
 import { existsSync } from "fs";
 import { dirname } from "path";
 import { fileURLToPath } from "url";
-import { mkdir, rm, writeFile } from "fs/promises";
+import { mkdir, writeFile } from "fs/promises";
 import { blue, yellow } from "kleur/colors";
 import parseArgs from "yargs-parser";
 import { CONFIG_FILE_NAMES, DB_PATH } from "../consts.js";
@@ -9,7 +9,7 @@ import { resolveDbConfig } from "../load-file.js";
 import { getManagedAppTokenOrExit } from "../tokens.js";
 import { getDbDirectoryUrl } from "../utils.js";
 import { fileURLIntegration } from "./file-url.js";
-import { typegen } from "./typegen.js";
+import { typegenInternal } from "./typegen.js";
 import { vitePluginDb } from "./vite-plugin-db.js";
 import { vitePluginInjectEnvTs } from "./vite-plugin-inject-env-ts.js";
 function astroDBIntegration() {
@@ -76,7 +76,7 @@ function astroDBIntegration() {
           await mkdir(dirname(fileURLToPath(localDbUrl)), { recursive: true });
           await writeFile(localDbUrl, "");
         }
-        await typegen({ tables: tables.get() ?? {}, root: config.root });
+        await typegenInternal({ tables: tables.get() ?? {}, root: config.root });
       },
       "astro:server:start": async ({ logger }) => {
         setTimeout(() => {

package/dist/core/integration/typegen.d.ts

@@ -1,5 +1,7 @@
+import type { AstroConfig } from 'astro';
 import type { DBTables } from '../types.js';
-export declare function typegen({ tables, root }: {
+export declare function typegen(astroConfig: Pick<AstroConfig, 'root' | 'integrations'>): Promise<void>;
+export declare function typegenInternal({ tables, root }: {
     tables: DBTables;
     root: URL;
 }): Promise<void>;

package/dist/core/integration/typegen.js

@@ -1,12 +1,14 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { DB_TYPES_FILE, RUNTIME_IMPORT } from "../consts.js";
-async function typegen({ tables, root }) {
-  const content = `// This file is generated by \`studio sync\`
+import { resolveDbConfig } from "../load-file.js";
+async function typegen(astroConfig) {
+  const { dbConfig } = await resolveDbConfig(astroConfig);
+  await typegenInternal({ tables: dbConfig.tables, root: astroConfig.root });
+}
+async function typegenInternal({ tables, root }) {
+  const content = `// This file is generated by Astro DB
 declare module 'astro:db' {
-	export const db: import(${RUNTIME_IMPORT}).SqliteDB;
-	export const dbUrl: string;
-
 ${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
 }
 `;
@@ -26,5 +28,6 @@ function generateTableType(name, collection) {
   return tableType;
 }
 export {
-  typegen
+  typegen,
+  typegenInternal
 };

package/dist/core/load-file.d.ts

@@ -2,7 +2,7 @@ import type { AstroConfig } from 'astro';
 /**
  * Load a user’s `astro:db` configuration file and additional configuration files provided by integrations.
  */
-export declare function resolveDbConfig({ root, integrations }: AstroConfig): Promise<{
+export declare function resolveDbConfig({ root, integrations, }: Pick<AstroConfig, 'root' | 'integrations'>): Promise<{
     /** Resolved `astro:db` config, including tables added by integrations. */
     dbConfig: {
         tables: Record<string, {

package/dist/core/load-file.js

@@ -11,7 +11,10 @@ import { dbConfigSchema } from "./schemas.js";
 import {} from "./types.js";
 import { getDbDirectoryUrl } from "./utils.js";
 const isDbIntegration = (integration) => "astro:db:setup" in integration.hooks;
-async function resolveDbConfig({ root, integrations }) {
+async function resolveDbConfig({
+  root,
+  integrations
+}) {
   const { mod, dependencies } = await loadUserConfigFile(root);
   const userDbConfig = dbConfigSchema.parse(mod?.default ?? {}, { errorMap });
   const dbConfig = { tables: userDbConfig.tables ?? {} };

package/dist/core/tokens.js

@@ -24,8 +24,18 @@ class ManagedRemoteAppToken {
   session;
   projectId;
   ttl;
+  expires;
   renewTimer;
   static async create(sessionToken, projectId) {
+    const { token: shortLivedAppToken, ttl } = await this.createToken(sessionToken, projectId);
+    return new ManagedRemoteAppToken({
+      token: shortLivedAppToken,
+      session: sessionToken,
+      projectId,
+      ttl
+    });
+  }
+  static async createToken(sessionToken, projectId) {
     const spinner = ora("Connecting to remote database...").start();
     const response = await safeFetch(
       new URL(`${getAstroStudioUrl()}/auth/cli/token-create`),
@@ -42,13 +52,8 @@ class ManagedRemoteAppToken {
     );
     await new Promise((resolve) => setTimeout(resolve, 2e3));
     spinner.succeed(green("Connected to remote database."));
-    const { token: shortLivedAppToken, ttl } = await response.json();
-    return new ManagedRemoteAppToken({
-      token: shortLivedAppToken,
-      session: sessionToken,
-      projectId,
-      ttl
-    });
+    const { token, ttl } = await response.json();
+    return { token, ttl };
   }
   constructor(options) {
     this.token = options.token;
@@ -56,6 +61,7 @@ class ManagedRemoteAppToken {
     this.projectId = options.projectId;
     this.ttl = options.ttl;
     this.renewTimer = setTimeout(() => this.renew(), 1e3 * 60 * 5 / 2);
+    this.expires = getExpiresFromTtl(this.ttl);
   }
   async fetch(url, body) {
     return safeFetch(
@@ -73,23 +79,41 @@ class ManagedRemoteAppToken {
       }
     );
   }
+  tokenIsValid() {
+    return /* @__PURE__ */ new Date() > this.expires;
+  }
+  createRenewTimer() {
+    return setTimeout(() => this.renew(), 1e3 * 60 * this.ttl / 2);
+  }
   async renew() {
     clearTimeout(this.renewTimer);
     delete this.renewTimer;
-    try {
+    if (this.tokenIsValid()) {
       const response = await this.fetch("/auth/cli/token-renew", {
         token: this.token,
         projectId: this.projectId
       });
       if (response.status === 200) {
-        this.renewTimer = setTimeout(() => this.renew(), 1e3 * 60 * this.ttl / 2);
+        this.expires = getExpiresFromTtl(this.ttl);
+        this.renewTimer = this.createRenewTimer();
       } else {
         throw new Error(`Unexpected response: ${response.status} ${response.statusText}`);
       }
-    } catch (error) {
-      const retryIn = 60 * this.ttl / 10;
-      console.error(`Failed to renew token. Retrying in ${retryIn} seconds.`, error?.message);
-      this.renewTimer = setTimeout(() => this.renew(), retryIn * 1e3);
+    } else {
+      try {
+        const { token, ttl } = await ManagedRemoteAppToken.createToken(
+          this.session,
+          this.projectId
+        );
+        this.token = token;
+        this.ttl = ttl;
+        this.expires = getExpiresFromTtl(ttl);
+        this.renewTimer = this.createRenewTimer();
+      } catch {
+        throw new Error(
+          `Token has expired and attempts to renew it have failed, please try again.`
+        );
+      }
     }
   }
   async destroy() {
@@ -140,6 +164,9 @@ async function getManagedAppTokenOrExit(token) {
   }
   return ManagedRemoteAppToken.create(sessionToken, projectId);
 }
+function getExpiresFromTtl(ttl) {
+  return new Date(Date.now() + ttl * 60 * 1e3);
+}
 export {
   PROJECT_ID_FILE,
   SESSION_LOGIN_FILE,

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export type { ResolvedCollectionConfig, TableConfig } from './core/types.js';
 export { cli } from './core/cli/index.js';
 export { integration as default } from './core/integration/index.js';
+export { typegen } from './core/integration/typegen.js';

package/dist/index.js

@@ -1,6 +1,8 @@
 import { cli } from "./core/cli/index.js";
 import { integration } from "./core/integration/index.js";
+import { typegen } from "./core/integration/typegen.js";
 export {
   cli,
-  integration as default
+  integration as default,
+  typegen
 };

package/dist/runtime/config.js

@@ -1,3 +1,4 @@
+import { sql as _sql } from "drizzle-orm";
 function createColumn(type, schema) {
   return {
     type,
@@ -30,7 +31,9 @@ function defineTable(userConfig) {
 function defineDb(userConfig) {
   return userConfig;
 }
-import { NOW, TRUE, FALSE } from "./index.js";
+const NOW = _sql`CURRENT_TIMESTAMP`;
+const TRUE = _sql`TRUE`;
+const FALSE = _sql`FALSE`;
 import {
   sql,
   eq,

package/dist/runtime/index.d.ts

@@ -1,15 +1,9 @@
-import { type ColumnDataType, sql } from 'drizzle-orm';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+import { type ColumnDataType } from 'drizzle-orm';
 import { type DBColumn, type DBTable } from '../core/types.js';
-export { sql };
-export type SqliteDB = LibSQLDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
 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>;
-export declare const FALSE: import("drizzle-orm").SQL<unknown>;
 export declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: string;
     schema: undefined;

package/dist/runtime/index.js

@@ -13,9 +13,6 @@ import { seedLocal } from "./seed-local.js";
 function hasPrimaryKey(column) {
   return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }
-const NOW = sql`CURRENT_TIMESTAMP`;
-const TRUE = sql`TRUE`;
-const FALSE = sql`FALSE`;
 const dateType = customType({
   dataType() {
     return "text";
@@ -114,13 +111,9 @@ function handleSerializedSQL(def) {
   return def;
 }
 export {
-  FALSE,
-  NOW,
-  TRUE,
   asDrizzleTable,
   createLocalDatabaseClient,
   createRemoteDatabaseClient,
   hasPrimaryKey,
-  seedLocal,
-  sql
+  seedLocal
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -80,8 +80,8 @@
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
     "vite": "^5.1.4",
-    "astro-scripts": "0.0.14",
-    "astro": "4.5.4"
+    "astro": "4.5.6",
+    "astro-scripts": "0.0.14"
   },
   "scripts": {
     "types:config": "tsc -p ./tsconfig.config-types.json",

package/virtual.d.ts

@@ -1,6 +1,9 @@
 declare module 'astro:db' {
 	type RuntimeConfig = typeof import('./dist/_internal/runtime/config.js');
 
+	export const db: import('./dist/_internal/runtime/config.js').LibSQLDatabase;
+	export const dbUrl: string;
+
 	export const sql: RuntimeConfig['sql'];
 	export const NOW: RuntimeConfig['NOW'];
 	export const TRUE: RuntimeConfig['TRUE'];

package/dist/_internal/core/errors.d.ts

@@ -1,14 +0,0 @@
-export declare const MISSING_SESSION_ID_ERROR: string;
-export declare const MISSING_PROJECT_ID_ERROR: string;
-export declare const MISSING_EXECUTE_PATH_ERROR: string;
-export declare const RENAME_TABLE_ERROR: (oldTable: string, newTable: string) => string;
-export declare const RENAME_COLUMN_ERROR: (oldSelector: string, newSelector: string) => string;
-export declare const FILE_NOT_FOUND_ERROR: (path: string) => string;
-export declare const SHELL_QUERY_MISSING_ERROR: string;
-export declare const SEED_ERROR: (error: string) => string;
-export declare const SEED_DEFAULT_EXPORT_ERROR: (fileName: string) => string;
-export declare const REFERENCE_DNE_ERROR: (columnName: string) => string;
-export declare const FOREIGN_KEY_DNE_ERROR: (tableName: string) => string;
-export declare const FOREIGN_KEY_REFERENCES_LENGTH_ERROR: (tableName: string) => string;
-export declare const FOREIGN_KEY_REFERENCES_EMPTY_ERROR: (tableName: string) => string;
-export declare const INTEGRATION_TABLE_CONFLICT_ERROR: (integrationName: string, tableName: string, isUserConflict: boolean) => string;

package/dist/_internal/runtime/db-client.d.ts

@@ -1,5 +0,0 @@
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-export declare function createLocalDatabaseClient({ dbUrl }: {
-    dbUrl: string;
-}): LibSQLDatabase;
-export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;

package/dist/_internal/runtime/index.d.ts

@@ -1,31 +0,0 @@
-import { type ColumnDataType, sql } from 'drizzle-orm';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-import { type DBColumn, type DBTable } from '../core/types.js';
-export { sql };
-export type SqliteDB = LibSQLDatabase;
-export type { Table } from './types.js';
-export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
-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>;
-export declare const FALSE: import("drizzle-orm").SQL<unknown>;
-export declare function asDrizzleTable(name: string, table: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
-    name: string;
-    schema: undefined;
-    columns: {
-        [x: string]: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: string;
-            tableName: string;
-            dataType: ColumnDataType;
-            columnType: string;
-            data: unknown;
-            driverParam: unknown;
-            notNull: false;
-            hasDefault: false;
-            enumValues: string[] | undefined;
-            baseColumn: never;
-        }, object>;
-    };
-    dialect: "sqlite";
-}>;

package/dist/_internal/runtime/queries.d.ts

@@ -1,71 +0,0 @@
-import type { BooleanColumn, ColumnType, DBColumn, DBTable, DateColumn, JsonColumn, NumberColumn, TextColumn } from '../core/types.js';
-export declare const SEED_DEV_FILE_NAME: string[];
-export declare function getDropTableIfExistsQuery(tableName: string): string;
-export declare function getCreateTableQuery(tableName: string, table: DBTable): string;
-export declare function getCreateIndexQueries(tableName: string, table: Pick<DBTable, 'indexes'>): string[];
-export declare function getCreateForeignKeyQueries(tableName: string, table: DBTable): string[];
-export declare function schemaTypeToSqlType(type: ColumnType): 'text' | 'integer';
-export declare function getModifiers(columnName: string, column: DBColumn): string;
-export declare function getReferencesConfig(column: DBColumn): {
-    type: "number";
-    schema: ({
-        unique: boolean;
-        deprecated: boolean;
-        name?: string | undefined;
-        label?: string | undefined;
-        collection?: string | undefined;
-    } & {
-        optional: boolean;
-        primaryKey: false;
-        default?: number | import("./types.js").SerializedSQL | undefined;
-    } & {
-        references?: any | undefined;
-    }) | ({
-        unique: boolean;
-        deprecated: boolean;
-        name?: string | undefined;
-        label?: string | undefined;
-        collection?: string | undefined;
-    } & {
-        primaryKey: true;
-        optional?: false | undefined;
-        default?: undefined;
-    } & {
-        references?: any | undefined;
-    });
-} | {
-    type: "text";
-    schema: ({
-        unique: boolean;
-        deprecated: boolean;
-        name?: string | undefined;
-        label?: string | undefined;
-        collection?: string | undefined;
-        default?: string | import("./types.js").SerializedSQL | undefined;
-        multiline?: boolean | undefined;
-    } & {
-        optional: boolean;
-        primaryKey: false;
-    } & {
-        references?: any | undefined;
-    }) | ({
-        unique: boolean;
-        deprecated: boolean;
-        name?: string | undefined;
-        label?: string | undefined;
-        collection?: string | undefined;
-        default?: string | import("./types.js").SerializedSQL | undefined;
-        multiline?: boolean | undefined;
-    } & {
-        primaryKey: true;
-        optional?: false | undefined;
-    } & {
-        references?: any | undefined;
-    });
-} | undefined;
-type WithDefaultDefined<T extends DBColumn> = T & {
-    schema: Required<Pick<T['schema'], 'default'>>;
-};
-type DBColumnWithDefault = WithDefaultDefined<TextColumn> | WithDefaultDefined<DateColumn> | WithDefaultDefined<NumberColumn> | WithDefaultDefined<BooleanColumn> | WithDefaultDefined<JsonColumn>;
-export declare function hasDefault(column: DBColumn): column is DBColumnWithDefault;
-export {};

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

@@ -1,10 +0,0 @@
-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/_internal/runtime/utils.d.ts

@@ -1,4 +0,0 @@
-/**
- * Small wrapper around fetch that throws an error if the response is not OK. Allows for custom error handling as well through the onNotOK callback.
- */
-export declare function safeFetch(url: Parameters<typeof fetch>[0], options?: Parameters<typeof fetch>[1], onNotOK?: (response: Response) => void | Promise<void>): Promise<Response>;