@astrojs/db 0.4.1 → 0.5.0

package/dist/{core → runtime}/queries.js

@@ -1,127 +1,100 @@
-import {
-} from "../core/types.js";
-import { bold } from "kleur/colors";
-import { sql, getTableName } from "drizzle-orm";
+import { LibsqlError } from "@libsql/client";
+import { sql } from "drizzle-orm";
 import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
-import { hasPrimaryKey } from "../runtime/index.js";
-import { isSerializedSQL } from "../runtime/types.js";
-import { SEED_EMPTY_ARRAY_ERROR, SEED_ERROR, SEED_WRITABLE_IN_PROD_ERROR } from "./errors.js";
+import { bold } from "kleur/colors";
+import {
+  FOREIGN_KEY_DNE_ERROR,
+  FOREIGN_KEY_REFERENCES_EMPTY_ERROR,
+  FOREIGN_KEY_REFERENCES_LENGTH_ERROR,
+  REFERENCE_DNE_ERROR,
+  SEED_ERROR
+} from "../core/errors.js";
+import { hasPrimaryKey } from "./index.js";
+import { isSerializedSQL } from "./types.js";
 const sqlite = new SQLiteAsyncDialect();
-async function recreateTables({
+const SEED_DEV_FILE_NAME = ["seed.ts", "seed.js", "seed.mjs", "seed.mts"];
+async function seedLocal({
   db,
-  tables
+  tables,
+  // Glob all potential seed files to catch renames and deletions.
+  fileGlob
 }) {
-  const setupQueries = [];
-  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);
-    setupQueries.push(dropQuery, createQuery, ...indexQueries.map((s) => sql.raw(s)));
-  }
-  for (const q of setupQueries) {
-    await db.run(q);
-  }
-}
-async function seedData({
-  db,
-  data,
-  logger,
-  mode
-}) {
-  const dataFns = Array.isArray(data) ? data : [data];
-  try {
-    for (const dataFn of dataFns) {
-      await dataFn({
-        seed: async (config, values) => {
-          seedErrorChecks(mode, config, values);
-          try {
-            await db.insert(config.table).values(values);
-          } catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            throw new Error(SEED_ERROR(getTableName(config.table), msg));
-          }
-        },
-        seedReturning: async (config, values) => {
-          seedErrorChecks(mode, config, values);
-          try {
-            let result = db.insert(config.table).values(values).returning();
-            if (!Array.isArray(values)) {
-              result = result.get();
-            }
-            return result;
-          } catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            throw new Error(SEED_ERROR(getTableName(config.table), msg));
-          }
-        },
-        db,
-        mode
+  await recreateTables({ db, tables });
+  for (const fileName of SEED_DEV_FILE_NAME) {
+    const key = Object.keys(fileGlob).find((f) => f.endsWith(fileName));
+    if (key) {
+      await fileGlob[key]().catch((e) => {
+        if (e instanceof LibsqlError) {
+          throw new Error(SEED_ERROR(e.message));
+        }
+        throw e;
       });
+      return;
     }
-  } catch (e) {
-    if (!(e instanceof Error))
-      throw e;
-    (logger ?? console).error(e.message);
   }
 }
-function seedErrorChecks(mode, { table, writable }, values) {
-  const tableName = getTableName(table);
-  if (writable && mode === "build" && process.env.ASTRO_DB_TEST_ENV !== "1") {
-    throw new Error(SEED_WRITABLE_IN_PROD_ERROR(tableName));
-  }
-  if (Array.isArray(values) && values.length === 0) {
-    throw new Error(SEED_EMPTY_ARRAY_ERROR(tableName));
+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))
+  ]);
 }
-function getCreateTableQuery(collectionName, collection) {
-  let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
+function getCreateTableQuery(tableName, table) {
+  let query = `CREATE TABLE ${sqlite.escapeName(tableName)} (`;
   const colQueries = [];
-  const colHasPrimaryKey = Object.entries(collection.columns).find(
+  const colHasPrimaryKey = Object.entries(table.columns).find(
     ([, column]) => hasPrimaryKey(column)
   );
   if (!colHasPrimaryKey) {
     colQueries.push("_id INTEGER PRIMARY KEY");
   }
-  for (const [columnName, column] of Object.entries(collection.columns)) {
+  for (const [columnName, column] of Object.entries(table.columns)) {
     const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
       column.type
     )}${getModifiers(columnName, column)}`;
     colQueries.push(colQuery);
   }
-  colQueries.push(...getCreateForeignKeyQueries(collectionName, collection));
+  colQueries.push(...getCreateForeignKeyQueries(tableName, table));
   query += colQueries.join(", ") + ")";
   return query;
 }
-function getCreateIndexQueries(collectionName, collection) {
+function getCreateIndexQueries(tableName, table) {
   let queries = [];
-  for (const [indexName, indexProps] of Object.entries(collection.indexes ?? {})) {
+  for (const [indexName, indexProps] of Object.entries(table.indexes ?? {})) {
     const onColNames = asArray(indexProps.on);
     const onCols = onColNames.map((colName) => sqlite.escapeName(colName));
     const unique = indexProps.unique ? "UNIQUE " : "";
     const indexQuery = `CREATE ${unique}INDEX ${sqlite.escapeName(
       indexName
-    )} ON ${sqlite.escapeName(collectionName)} (${onCols.join(", ")})`;
+    )} ON ${sqlite.escapeName(tableName)} (${onCols.join(", ")})`;
     queries.push(indexQuery);
   }
   return queries;
 }
-function getCreateForeignKeyQueries(collectionName, collection) {
+function getCreateForeignKeyQueries(tableName, table) {
   let queries = [];
-  for (const foreignKey of collection.foreignKeys ?? []) {
+  for (const foreignKey of table.foreignKeys ?? []) {
     const columns = asArray(foreignKey.columns);
     const references = asArray(foreignKey.references);
     if (columns.length !== references.length) {
-      throw new Error(
-        `Foreign key on ${collectionName} is misconfigured. \`columns\` and \`references\` must be the same length.`
-      );
+      throw new Error(FOREIGN_KEY_REFERENCES_LENGTH_ERROR(tableName));
+    }
+    const firstReference = references[0];
+    if (!firstReference) {
+      throw new Error(FOREIGN_KEY_REFERENCES_EMPTY_ERROR(tableName));
     }
-    const referencedCollection = references[0]?.schema.collection;
-    if (!referencedCollection) {
-      throw new Error(
-        `Foreign key on ${collectionName} is misconfigured. \`references\` cannot be empty.`
-      );
+    const referencedTable = firstReference.schema.collection;
+    if (!referencedTable) {
+      throw new Error(FOREIGN_KEY_DNE_ERROR(tableName));
     }
-    const query = `FOREIGN KEY (${columns.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(referencedTable)}(${references.map((r) => sqlite.escapeName(r.schema.name)).join(", ")})`;
     queries.push(query);
   }
   return queries;
@@ -156,13 +129,11 @@ function getModifiers(columnName, column) {
   }
   const references = getReferencesConfig(column);
   if (references) {
-    const { collection, name } = references.schema;
-    if (!collection || !name) {
-      throw new Error(
-        `Column ${collection}.${name} references a collection that does not exist. Did you apply the referenced collection to the \`tables\` object in your Astro config?`
-      );
+    const { collection: tableName, name } = references.schema;
+    if (!tableName || !name) {
+      throw new Error(REFERENCE_DNE_ERROR(columnName));
     }
-    modifiers += ` REFERENCES ${sqlite.escapeName(collection)} (${sqlite.escapeName(name)})`;
+    modifiers += ` REFERENCES ${sqlite.escapeName(tableName)} (${sqlite.escapeName(name)})`;
   }
   return modifiers;
 }
@@ -218,6 +189,7 @@ function getDefaultValueSql(columnName, column) {
   }
 }
 export {
+  SEED_DEV_FILE_NAME,
   getCreateForeignKeyQueries,
   getCreateIndexQueries,
   getCreateTableQuery,
@@ -226,5 +198,5 @@ export {
   hasDefault,
   recreateTables,
   schemaTypeToSqlType,
-  seedData
+  seedLocal
 };

package/dist/runtime/types.d.ts

@@ -1,6 +1,6 @@
-import type { ColumnDataType, ColumnBaseConfig } from 'drizzle-orm';
+import type { ColumnBaseConfig, ColumnDataType } from 'drizzle-orm';
 import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
-import type { DBColumn, ColumnsConfig } from '../core/types.js';
+import type { ColumnsConfig, DBColumn, OutputColumnsConfig } from '../core/types.js';
 type GeneratedConfig<T extends ColumnDataType = ColumnDataType> = Pick<ColumnBaseConfig<T, string>, 'name' | 'tableName' | 'notNull' | 'hasDefault'>;
 export type AstroText<T extends GeneratedConfig<'string'>> = SQLiteColumn<T & {
     data: string;
@@ -43,7 +43,7 @@ export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
     baseColumn: never;
 }>;
 export type Column<T extends DBColumn['type'], S extends GeneratedConfig> = T extends 'boolean' ? AstroBoolean<S> : T extends 'number' ? AstroNumber<S> : T extends 'text' ? AstroText<S> : T extends 'date' ? AstroDate<S> : T extends 'json' ? AstroJson<S> : never;
-export type Table<TTableName extends string, TColumns extends ColumnsConfig> = SQLiteTableWithColumns<{
+export type Table<TTableName extends string, TColumns extends OutputColumnsConfig | ColumnsConfig> = SQLiteTableWithColumns<{
     name: TTableName;
     schema: undefined;
     dialect: 'sqlite';

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export { asDrizzleTable } from './runtime/index.js';

package/dist/utils.js

@@ -0,0 +1,4 @@
+import { asDrizzleTable } from "./runtime/index.js";
+export {
+  asDrizzleTable
+};

package/index.d.ts

@@ -1,3 +1,5 @@
-/// <reference types="./config-augment.d.ts" />
-export * from './dist/index.js';
-export { default } from './dist/index.js';
+export { default, cli } from './dist/index.js';
+
+declare module 'astro:db' {
+	export { defineTable, defineDB, column, sql, NOW, TRUE, FALSE } from './dist/index.js';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,10 @@
       "types": "./index.d.ts",
       "import": "./dist/index.js"
     },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
@@ -20,6 +24,10 @@
       "types": "./dist/runtime/drizzle.d.ts",
       "import": "./dist/runtime/drizzle.js"
     },
+    "./runtime/config": {
+      "types": "./dist/runtime/config.d.ts",
+      "import": "./dist/runtime/config.js"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {
@@ -27,11 +35,17 @@
       ".": [
         "./index.d.ts"
       ],
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
       "runtime": [
         "./dist/runtime/index.d.ts"
       ],
       "runtime/drizzle": [
         "./dist/runtime/drizzle.d.ts"
+      ],
+      "runtime/config": [
+        "./dist/runtime/config.d.ts"
       ]
     }
   },
@@ -46,6 +60,7 @@
   ],
   "dependencies": {
     "@libsql/client": "^0.4.3",
+    "async-listen": "^3.0.1",
     "deep-diff": "^1.0.2",
     "drizzle-orm": "^0.28.6",
     "kleur": "^4.1.5",
@@ -67,8 +82,8 @@
     "cheerio": "1.0.0-rc.12",
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
-    "vite": "^4.4.11",
-    "astro": "4.4.5",
+    "vite": "^5.1.4",
+    "astro": "4.4.9",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

package/config-augment.d.ts

@@ -1,4 +0,0 @@
-declare namespace Config {
-	type DBUserConfig = import('./dist/core/types.js').DBUserConfig;
-	export interface Database extends DBUserConfig {}
-}

package/dist/core/integration/load-astro-config.d.ts

@@ -1,6 +0,0 @@
-/**
- * Pulled from the mothership, Astro core ❤️
- *
- * @see https://github.com/withastro/astro/blob/main/packages/astro/src/core/config/config.ts#L121
- */
-export declare function loadAstroConfig(root: string): Promise<Record<string, unknown>>;

package/dist/core/integration/load-astro-config.js

@@ -1,79 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { bold, red } from "kleur/colors";
-import { createServer } from "vite";
-async function loadAstroConfig(root) {
-  const configPath = search(root);
-  if (!configPath)
-    return {};
-  try {
-    return await loadConfigWithVite(configPath);
-  } catch (e) {
-    console.error(`${bold(red("[astro]"))} Unable to load Astro config.
-`);
-    throw e;
-  }
-}
-function search(root) {
-  const paths = [
-    "astro.config.mjs",
-    "astro.config.js",
-    "astro.config.ts",
-    "astro.config.mts",
-    "astro.config.cjs",
-    "astro.config.cts"
-  ].map((p) => path.join(root, p));
-  for (const file of paths) {
-    if (fs.existsSync(file)) {
-      return file;
-    }
-  }
-}
-async function loadConfigWithVite(configPath) {
-  if (/\.[cm]?js$/.test(configPath)) {
-    try {
-      const config = await import(
-        /* @vite-ignore */
-        pathToFileURL(configPath).toString() + "?t=" + Date.now()
-      );
-      return config.default ?? {};
-    } catch (e) {
-    }
-  }
-  let server;
-  try {
-    server = await createViteServer();
-    const mod = await server.ssrLoadModule(configPath, { fixStacktrace: true });
-    return mod.default ?? {};
-  } finally {
-    if (server) {
-      await server.close();
-    }
-  }
-}
-async function createViteServer() {
-  const viteServer = await createServer({
-    server: { middlewareMode: true, hmr: false, watch: { ignored: ["**"] } },
-    optimizeDeps: { disabled: true },
-    clearScreen: false,
-    appType: "custom",
-    ssr: {
-      // NOTE: Vite doesn't externalize linked packages by default. During testing locally,
-      // these dependencies trip up Vite's dev SSR transform. Awaiting upstream feature:
-      // https://github.com/vitejs/vite/pull/10939
-      external: [
-        "@astrojs/tailwind",
-        "@astrojs/mdx",
-        "@astrojs/react",
-        "@astrojs/preact",
-        "@astrojs/sitemap",
-        "@astrojs/markdoc"
-      ]
-    }
-  });
-  return viteServer;
-}
-export {
-  loadAstroConfig
-};