@astrojs/db 0.3.5 → 0.4.0

package/dist/core/integration/typegen.js

@@ -1,14 +1,14 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { DB_TYPES_FILE, RUNTIME_DRIZZLE_IMPORT, RUNTIME_IMPORT } from "../consts.js";
-async function typegen({ collections, root }) {
+async function typegen({ tables, root }) {
   const content = `// This file is generated by \`studio sync\`
 declare module 'astro:db' {
 	export const db: import(${RUNTIME_IMPORT}).SqliteDB;
 	export const dbUrl: string;
 	export * from ${RUNTIME_DRIZZLE_IMPORT};
 
-${Object.entries(collections).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
+${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
 }
 `;
   const dotAstroDir = new URL(".astro/", root);
@@ -22,13 +22,13 @@ function generateTableType(name, collection) {
 		${JSON.stringify(name)},
 		${JSON.stringify(
     Object.fromEntries(
-      Object.entries(collection.fields).map(([fieldName, field]) => [
-        fieldName,
+      Object.entries(collection.columns).map(([columnName, column]) => [
+        columnName,
         {
-          // Only select fields Drizzle needs for inference
-          type: field.type,
-          optional: field.schema.optional,
-          default: field.schema.default
+          // Only select columns Drizzle needs for inference
+          type: column.type,
+          optional: column.schema.optional,
+          default: column.schema.default
         }
       ])
     )

package/dist/core/integration/vite-plugin-db.d.ts

@@ -1,20 +1,25 @@
-import type { DBCollections } from '../types.js';
+import type { DBTables } from '../types.js';
 import type { VitePlugin } from '../utils.js';
-export declare function vitePluginDb(params: {
+type LateSchema = {
+    tables: () => DBTables;
+};
+type VitePluginDBParams = {
     connectToStudio: false;
-    collections: DBCollections;
+    schemas: LateSchema;
     root: URL;
 } | {
     connectToStudio: true;
-    collections: DBCollections;
+    schemas: LateSchema;
     appToken: string;
     root: URL;
-}): VitePlugin;
-export declare function getVirtualModContents({ collections, root, }: {
-    collections: DBCollections;
+};
+export declare function vitePluginDb(params: VitePluginDBParams): VitePlugin;
+export declare function getVirtualModContents({ tables, root }: {
+    tables: DBTables;
     root: URL;
 }): string;
-export declare function getStudioVirtualModContents({ collections, appToken, }: {
-    collections: DBCollections;
+export declare function getStudioVirtualModContents({ tables, appToken, }: {
+    tables: DBTables;
     appToken: string;
 }): string;
+export {};

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

@@ -13,23 +13,26 @@ function vitePluginDb(params) {
       if (id !== resolvedVirtualModuleId)
         return;
       if (params.connectToStudio) {
-        return getStudioVirtualModContents(params);
+        return getStudioVirtualModContents({
+          appToken: params.appToken,
+          tables: params.schemas.tables()
+        });
       }
-      return getVirtualModContents(params);
+      return getVirtualModContents({
+        root: params.root,
+        tables: params.schemas.tables()
+      });
     }
   };
 }
-function getVirtualModContents({
-  collections,
-  root
-}) {
+function getVirtualModContents({ tables, root }) {
   const dbUrl = new URL(DB_PATH, root);
   return `
 import { collectionToTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
 import dbUrl from ${JSON.stringify(`${dbUrl}?fileurl`)};
 
 const params = ${JSON.stringify({
-    collections,
+    tables,
     seeding: false
   })};
 params.dbUrl = dbUrl;
@@ -38,11 +41,11 @@ export const db = await createLocalDatabaseClient(params);
 
 export * from ${RUNTIME_DRIZZLE_IMPORT};
 
-${getStringifiedCollectionExports(collections)}
+${getStringifiedCollectionExports(tables)}
 `;
 }
 function getStudioVirtualModContents({
-  collections,
+  tables,
   appToken
 }) {
   return `
@@ -53,11 +56,11 @@ export const db = await createRemoteDatabaseClient(${JSON.stringify(
   )}, import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL);
 export * from ${RUNTIME_DRIZZLE_IMPORT};
 
-${getStringifiedCollectionExports(collections)}
+${getStringifiedCollectionExports(tables)}
 	`;
 }
-function getStringifiedCollectionExports(collections) {
-  return Object.entries(collections).map(
+function getStringifiedCollectionExports(tables) {
+  return Object.entries(tables).map(
     ([name, collection]) => `export const ${name} = collectionToTable(${JSON.stringify(name)}, ${JSON.stringify(
       collection
     )}, false)`

package/dist/core/integration/vite-plugin-inject-env-ts.d.ts

@@ -1,9 +1,11 @@
 import type { VitePlugin } from '../utils.js';
+import type { AstroIntegrationLogger } from 'astro';
 export declare function vitePluginInjectEnvTs({ srcDir, root }: {
     srcDir: URL;
     root: URL;
-}): VitePlugin;
-export declare function setUpEnvTs({ srcDir, root }: {
+}, logger: AstroIntegrationLogger): VitePlugin;
+export declare function setUpEnvTs({ srcDir, root, logger, }: {
     srcDir: URL;
     root: URL;
+    logger: AstroIntegrationLogger;
 }): Promise<void>;

package/dist/core/integration/vite-plugin-inject-env-ts.js

@@ -5,16 +5,20 @@ import { fileURLToPath } from "node:url";
 import { bold, cyan } from "kleur/colors";
 import { normalizePath } from "vite";
 import { DB_TYPES_FILE } from "../consts.js";
-function vitePluginInjectEnvTs({ srcDir, root }) {
+function vitePluginInjectEnvTs({ srcDir, root }, logger) {
   return {
     name: "db-inject-env-ts",
     enforce: "post",
     async config() {
-      await setUpEnvTs({ srcDir, root });
+      await setUpEnvTs({ srcDir, root, logger });
     }
   };
 }
-async function setUpEnvTs({ srcDir, root }) {
+async function setUpEnvTs({
+  srcDir,
+  root,
+  logger
+}) {
   const envTsPath = getEnvTsPath({ srcDir });
   const envTsPathRelativetoRoot = normalizePath(
     path.relative(fileURLToPath(root), fileURLToPath(envTsPath))
@@ -29,7 +33,7 @@ async function setUpEnvTs({ srcDir, root }) {
       typesEnvContents = `${dbTypeReference}
 ${typesEnvContents}`;
       await writeFile(envTsPath, typesEnvContents, "utf-8");
-      console.info(`${cyan(bold("[astro:db]"))} Added ${bold(envTsPathRelativetoRoot)} types`);
+      logger.info(`${cyan(bold("[astro:db]"))} Added ${bold(envTsPathRelativetoRoot)} types`);
     }
   }
 }

package/dist/core/queries.d.ts

@@ -1,10 +1,10 @@
 import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
-import { type BooleanField, type DBCollection, type DBCollections, type DBField, type DateField, type FieldType, type JsonField, type NumberField, type TextField } from '../core/types.js';
+import { type BooleanColumn, type DBTable, type DBTables, type DBColumn, type DateColumn, type ColumnType, type JsonColumn, type NumberColumn, type TextColumn } from '../core/types.js';
 import type { AstroIntegrationLogger } from 'astro';
 import type { DBUserConfig } from '../core/types.js';
-export declare function recreateTables({ db, collections, }: {
+export declare function recreateTables({ db, tables, }: {
     db: SqliteRemoteDatabase;
-    collections: DBCollections;
+    tables: DBTables;
 }): Promise<void>;
 export declare function seedData({ db, data, logger, mode, }: {
     db: SqliteRemoteDatabase;
@@ -12,12 +12,12 @@ export declare function seedData({ db, data, logger, mode, }: {
     logger?: AstroIntegrationLogger;
     mode: 'dev' | 'build';
 }): Promise<void>;
-export declare function getCreateTableQuery(collectionName: string, collection: DBCollection): string;
-export declare function getCreateIndexQueries(collectionName: string, collection: Pick<DBCollection, 'indexes'>): string[];
-export declare function getCreateForeignKeyQueries(collectionName: string, collection: DBCollection): string[];
-export declare function schemaTypeToSqlType(type: FieldType): 'text' | 'integer';
-export declare function getModifiers(fieldName: string, field: DBField): string;
-export declare function getReferencesConfig(field: DBField): {
+export declare function getCreateTableQuery(collectionName: string, collection: DBTable): string;
+export declare function getCreateIndexQueries(collectionName: string, collection: Pick<DBTable, 'indexes'>): string[];
+export declare function getCreateForeignKeyQueries(collectionName: string, collection: 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;
@@ -70,9 +70,9 @@ export declare function getReferencesConfig(field: DBField): {
         references?: any | undefined;
     });
 } | undefined;
-type WithDefaultDefined<T extends DBField> = T & {
+type WithDefaultDefined<T extends DBColumn> = T & {
     schema: Required<Pick<T['schema'], 'default'>>;
 };
-type DBFieldWithDefault = WithDefaultDefined<TextField> | WithDefaultDefined<DateField> | WithDefaultDefined<NumberField> | WithDefaultDefined<BooleanField> | WithDefaultDefined<JsonField>;
-export declare function hasDefault(field: DBField): field is DBFieldWithDefault;
+type DBColumnWithDefault = WithDefaultDefined<TextColumn> | WithDefaultDefined<DateColumn> | WithDefaultDefined<NumberColumn> | WithDefaultDefined<BooleanColumn> | WithDefaultDefined<JsonColumn>;
+export declare function hasDefault(column: DBColumn): column is DBColumnWithDefault;
 export {};

package/dist/core/queries.js

@@ -1,6 +1,6 @@
 import {
 } from "../core/types.js";
-import { bold, red } from "kleur/colors";
+import { bold } from "kleur/colors";
 import { sql, getTableName } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
 import { hasPrimaryKey } from "../runtime/index.js";
@@ -9,10 +9,10 @@ import { SEED_WRITABLE_IN_PROD_ERROR } from "./errors.js";
 const sqlite = new SQLiteAsyncDialect();
 async function recreateTables({
   db,
-  collections
+  tables
 }) {
   const setupQueries = [];
-  for (const [name, collection] of Object.entries(collections)) {
+  for (const [name, collection] of Object.entries(tables)) {
     const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${sqlite.escapeName(name)}`);
     const createQuery = sql.raw(getCreateTableQuery(name, collection));
     const indexQueries = getCreateIndexQueries(name, collection);
@@ -29,28 +29,31 @@ async function seedData({
   mode
 }) {
   try {
-    await data({
-      seed: async ({ table, writable }, values) => {
-        if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
-          (logger ?? console).error(SEED_WRITABLE_IN_PROD_ERROR(getTableName(table)));
-          process.exit(1);
-        }
-        await db.insert(table).values(values);
-      },
-      seedReturning: async ({ table, writable }, values) => {
-        if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
-          (logger ?? console).error(SEED_WRITABLE_IN_PROD_ERROR(getTableName(table)));
-          process.exit(1);
-        }
-        let result = db.insert(table).values(values).returning();
-        if (!Array.isArray(values)) {
-          result = result.get();
-        }
-        return result;
-      },
-      db,
-      mode
-    });
+    const dataFns = Array.isArray(data) ? data : [data];
+    for (const dataFn of dataFns) {
+      await dataFn({
+        seed: async ({ table, writable }, values) => {
+          if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+            (logger ?? console).error(SEED_WRITABLE_IN_PROD_ERROR(getTableName(table)));
+            process.exit(1);
+          }
+          await db.insert(table).values(values);
+        },
+        seedReturning: async ({ table, writable }, values) => {
+          if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
+            (logger ?? console).error(SEED_WRITABLE_IN_PROD_ERROR(getTableName(table)));
+            process.exit(1);
+          }
+          let result = db.insert(table).values(values).returning();
+          if (!Array.isArray(values)) {
+            result = result.get();
+          }
+          return result;
+        },
+        db,
+        mode
+      });
+    }
   } catch (error) {
     (logger ?? console).error(
       `Failed to seed data. Did you update to match recent schema changes?`
@@ -61,13 +64,13 @@ async function seedData({
 function getCreateTableQuery(collectionName, collection) {
   let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
   const colQueries = [];
-  const colHasPrimaryKey = Object.entries(collection.fields).find(
-    ([, field]) => hasPrimaryKey(field)
+  const colHasPrimaryKey = Object.entries(collection.columns).find(
+    ([, column]) => hasPrimaryKey(column)
   );
   if (!colHasPrimaryKey) {
     colQueries.push("_id INTEGER PRIMARY KEY");
   }
-  for (const [columnName, column] of Object.entries(collection.fields)) {
+  for (const [columnName, column] of Object.entries(collection.columns)) {
     const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
       column.type
     )}${getModifiers(columnName, column)}`;
@@ -93,11 +96,11 @@ function getCreateIndexQueries(collectionName, collection) {
 function getCreateForeignKeyQueries(collectionName, collection) {
   let queries = [];
   for (const foreignKey of collection.foreignKeys ?? []) {
-    const fields = asArray(foreignKey.fields);
+    const columns = asArray(foreignKey.columns);
     const references = asArray(foreignKey.references);
-    if (fields.length !== references.length) {
+    if (columns.length !== references.length) {
       throw new Error(
-        `Foreign key on ${collectionName} is misconfigured. \`fields\` and \`references\` must be the same length.`
+        `Foreign key on ${collectionName} is misconfigured. \`columns\` and \`references\` must be the same length.`
       );
     }
     const referencedCollection = references[0]?.schema.collection;
@@ -106,7 +109,7 @@ function getCreateForeignKeyQueries(collectionName, collection) {
         `Foreign key on ${collectionName} is misconfigured. \`references\` cannot be empty.`
       );
     }
-    const query = `FOREIGN KEY (${fields.map((f) => sqlite.escapeName(f)).join(", ")}) REFERENCES ${sqlite.escapeName(referencedCollection)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
+    const query = `FOREIGN KEY (${columns.map((f) => sqlite.escapeName(f)).join(", ")}) REFERENCES ${sqlite.escapeName(referencedCollection)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
     queries.push(query);
   }
   return queries;
@@ -125,43 +128,43 @@ function schemaTypeToSqlType(type) {
       return "integer";
   }
 }
-function getModifiers(fieldName, field) {
+function getModifiers(columnName, column) {
   let modifiers = "";
-  if (hasPrimaryKey(field)) {
+  if (hasPrimaryKey(column)) {
     return " PRIMARY KEY";
   }
-  if (!field.schema.optional) {
+  if (!column.schema.optional) {
     modifiers += " NOT NULL";
   }
-  if (field.schema.unique) {
+  if (column.schema.unique) {
     modifiers += " UNIQUE";
   }
-  if (hasDefault(field)) {
-    modifiers += ` DEFAULT ${getDefaultValueSql(fieldName, field)}`;
+  if (hasDefault(column)) {
+    modifiers += ` DEFAULT ${getDefaultValueSql(columnName, column)}`;
   }
-  const references = getReferencesConfig(field);
+  const references = getReferencesConfig(column);
   if (references) {
     const { collection, name } = references.schema;
     if (!collection || !name) {
       throw new Error(
-        `Field ${collection}.${name} references a collection that does not exist. Did you apply the referenced collection to the \`collections\` object in your Astro config?`
+        `Column ${collection}.${name} references a collection that does not exist. Did you apply the referenced collection to the \`tables\` object in your Astro config?`
       );
     }
     modifiers += ` REFERENCES ${sqlite.escapeName(collection)} (${sqlite.escapeName(name)})`;
   }
   return modifiers;
 }
-function getReferencesConfig(field) {
-  const canHaveReferences = field.type === "number" || field.type === "text";
+function getReferencesConfig(column) {
+  const canHaveReferences = column.type === "number" || column.type === "text";
   if (!canHaveReferences)
     return void 0;
-  return field.schema.references;
+  return column.schema.references;
 }
-function hasDefault(field) {
-  if (field.schema.default !== void 0) {
+function hasDefault(column) {
+  if (column.schema.default !== void 0) {
     return true;
   }
-  if (hasPrimaryKey(field) && field.type === "number") {
+  if (hasPrimaryKey(column) && column.type === "number") {
     return true;
   }
   return false;