@astrojs/db 0.1.18 → 0.1.20

package/dist/{vite-plugin-db.js → core/integration/vite-plugin-db.js}

@@ -1,4 +1,5 @@
-import { DRIZZLE_MOD_IMPORT, INTERNAL_MOD_IMPORT, VIRTUAL_MODULE_ID, DB_PATH } from "./consts.js";
+import { RUNTIME_IMPORT, VIRTUAL_MODULE_ID, DB_PATH, RUNTIME_DRIZZLE_IMPORT } from "../consts.js";
+import { fileURLToPath } from "node:url";
 const resolvedVirtualModuleId = "\0" + VIRTUAL_MODULE_ID;
 function vitePluginDb(params) {
   return {
@@ -19,12 +20,11 @@ function vitePluginDb(params) {
     }
   };
 }
-function getVirtualModContents({
-  collections
-}) {
+function getVirtualModContents({ collections, root }) {
+  const dbUrl = new URL(DB_PATH, root);
   return `
-import { collectionToTable, createLocalDatabaseClient } from ${INTERNAL_MOD_IMPORT};
-import dbUrl from './.astro/content.db?fileurl';
+import { collectionToTable, createLocalDatabaseClient } from ${RUNTIME_IMPORT};
+import dbUrl from '${fileURLToPath(dbUrl)}?fileurl';
 
 const params = ${JSON.stringify({
     collections,
@@ -34,7 +34,7 @@ params.dbUrl = dbUrl;
 
 export const db = await createLocalDatabaseClient(params);
 
-export * from ${DRIZZLE_MOD_IMPORT};
+export * from ${RUNTIME_DRIZZLE_IMPORT};
 
 ${getStringifiedCollectionExports(collections)}
 `;
@@ -44,12 +44,12 @@ function getStudioVirtualModContents({
   appToken
 }) {
   return `
-import {collectionToTable, createRemoteDatabaseClient} from ${INTERNAL_MOD_IMPORT};
+import {collectionToTable, createRemoteDatabaseClient} from ${RUNTIME_IMPORT};
 
 export const db = await createRemoteDatabaseClient(${JSON.stringify(
     appToken
   )}, import.meta.env.ASTRO_STUDIO_REMOTE_DB_URL);
-export * from ${DRIZZLE_MOD_IMPORT};
+export * from ${RUNTIME_DRIZZLE_IMPORT};
 
 ${getStringifiedCollectionExports(collections)}
 	`;

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

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

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { bold, cyan } from "kleur/colors";
 import { normalizePath } from "vite";
-import { DB_TYPES_FILE } from "./consts.js";
+import { DB_TYPES_FILE } from "../consts.js";
 function vitePluginInjectEnvTs({ srcDir, root }) {
   return {
     name: "db-inject-env-ts",

package/dist/core/queries.d.ts

@@ -0,0 +1,19 @@
+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 { AstroIntegrationLogger } from 'astro';
+import type { DBUserConfig } from '../core/types.js';
+export declare function setupDbTables({ db, data, collections, logger, mode, }: {
+    db: SqliteRemoteDatabase;
+    data?: DBUserConfig['data'];
+    collections: DBCollections;
+    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 schemaTypeToSqlType(type: FieldType): 'text' | 'integer';
+export declare function getModifiers(fieldName: string, field: DBField): string;
+type WithDefaultDefined<T extends DBField> = T & Required<Pick<T, 'default'>>;
+type DBFieldWithDefault = WithDefaultDefined<TextField> | WithDefaultDefined<DateField> | WithDefaultDefined<NumberField> | WithDefaultDefined<BooleanField> | WithDefaultDefined<JsonField>;
+export declare function hasDefault(field: DBField): field is DBFieldWithDefault;
+export {};

package/dist/core/queries.js

@@ -0,0 +1,151 @@
+import {
+} from "../core/types.js";
+import { bold } from "kleur/colors";
+import { sql } from "drizzle-orm";
+import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { collectionToTable, hasPrimaryKey } from "../runtime/index.js";
+const sqlite = new SQLiteAsyncDialect();
+async function setupDbTables({
+  db,
+  data,
+  collections,
+  logger,
+  mode
+}) {
+  const setupQueries = [];
+  for (const [name, collection] of Object.entries(collections)) {
+    const dropQuery = sql.raw(`DROP TABLE IF EXISTS ${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);
+  }
+  if (data) {
+    for (const [name, collection] of Object.entries(collections)) {
+      const table = collectionToTable(name, collection);
+      collection._setMeta?.({ table });
+    }
+    try {
+      await data({
+        async seed({ table }, values) {
+          const result = Array.isArray(values) ? (
+            // TODO: fix values typing once we can infer fields type correctly
+            await db.insert(table).values(values).returning()
+          ) : await db.insert(table).values(values).returning().get();
+          return result;
+        },
+        db,
+        mode
+      });
+    } catch (e) {
+      (logger ?? console).error(
+        `Failed to seed data. Did you update to match recent schema changes? Full error:
+
+${e}`
+      );
+    }
+  }
+}
+function getCreateTableQuery(collectionName, collection) {
+  let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
+  const colQueries = [];
+  const colHasPrimaryKey = Object.entries(collection.fields).find(
+    ([, field]) => hasPrimaryKey(field)
+  );
+  if (!colHasPrimaryKey) {
+    colQueries.push("_id INTEGER PRIMARY KEY");
+  }
+  for (const [columnName, column] of Object.entries(collection.fields)) {
+    const colQuery = `${sqlite.escapeName(columnName)} ${schemaTypeToSqlType(
+      column.type
+    )}${getModifiers(columnName, column)}`;
+    colQueries.push(colQuery);
+  }
+  query += colQueries.join(", ") + ")";
+  return query;
+}
+function getCreateIndexQueries(collectionName, collection) {
+  let queries = [];
+  for (const [indexName, indexProps] of Object.entries(collection.indexes ?? {})) {
+    const onColNames = Array.isArray(indexProps.on) ? indexProps.on : [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(", ")})`;
+    queries.push(indexQuery);
+  }
+  return queries;
+}
+function schemaTypeToSqlType(type) {
+  switch (type) {
+    case "date":
+    case "text":
+    case "json":
+      return "text";
+    case "number":
+    case "boolean":
+      return "integer";
+  }
+}
+function getModifiers(fieldName, field) {
+  let modifiers = "";
+  if (hasPrimaryKey(field)) {
+    return " PRIMARY KEY";
+  }
+  if (!field.optional) {
+    modifiers += " NOT NULL";
+  }
+  if (field.unique) {
+    modifiers += " UNIQUE";
+  }
+  if (hasDefault(field)) {
+    modifiers += ` DEFAULT ${getDefaultValueSql(fieldName, field)}`;
+  }
+  return modifiers;
+}
+function hasDefault(field) {
+  if (field.default !== void 0) {
+    return true;
+  }
+  if (hasPrimaryKey(field) && field.type === "number") {
+    return true;
+  }
+  return false;
+}
+function getDefaultValueSql(columnName, column) {
+  switch (column.type) {
+    case "boolean":
+      return column.default ? "TRUE" : "FALSE";
+    case "number":
+      return `${column.default || "AUTOINCREMENT"}`;
+    case "text":
+      return sqlite.escapeString(column.default);
+    case "date":
+      return column.default === "now" ? "CURRENT_TIMESTAMP" : sqlite.escapeString(column.default);
+    case "json": {
+      let stringified = "";
+      try {
+        stringified = JSON.stringify(column.default);
+      } catch (e) {
+        console.log(
+          `Invalid default value for column ${bold(
+            columnName
+          )}. Defaults must be valid JSON when using the \`json()\` type.`
+        );
+        process.exit(0);
+      }
+      return sqlite.escapeString(stringified);
+    }
+  }
+}
+export {
+  getCreateIndexQueries,
+  getCreateTableQuery,
+  getModifiers,
+  hasDefault,
+  schemaTypeToSqlType,
+  setupDbTables
+};