@astrojs/db 0.1.2 → 0.1.3

package/dist/internal.js

@@ -17,6 +17,9 @@ import {
 import { z } from "zod";
 import { nanoid } from "nanoid";
 const sqlite = new SQLiteAsyncDialect();
+function hasPrimaryKey(field) {
+  return "primaryKey" in field && !!field.primaryKey;
+}
 function isReadableCollection(collection) {
   return !collection.writable;
 }
@@ -55,8 +58,10 @@ async function createLocalDatabaseClient({
 }
 async function setupDbTables({
   db,
+  data,
   collections,
-  logger
+  logger,
+  mode
 }) {
   const setupQueries = [];
   for (const [name, collection] of Object.entries(collections)) {
@@ -67,6 +72,15 @@ async function setupDbTables({
   for (const q of setupQueries) {
     await db.run(q);
   }
+  if (data) {
+    const ormObjects = Object.fromEntries(
+      Object.entries(collections).map(([name, collection]) => {
+        const table = collectionToTable(name, collection, false);
+        return [name, table];
+      })
+    );
+    await data({ db, ...ormObjects, mode });
+  }
   for (const [name, collection] of Object.entries(collections)) {
     if (!isReadableCollection(collection) || !collection.data)
       continue;
@@ -86,7 +100,13 @@ ${e}`
 }
 function getCreateTableQuery(collectionName, collection) {
   let query = `CREATE TABLE ${sqlite.escapeName(collectionName)} (`;
-  const colQueries = ['"id" text PRIMARY KEY'];
+  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
@@ -107,28 +127,37 @@ function schemaTypeToSqlType(type) {
       return "integer";
   }
 }
-function getModifiers(columnName, column) {
+function getModifiers(fieldName, field) {
   let modifiers = "";
-  if (!column.optional) {
+  if (hasPrimaryKey(field)) {
+    return " PRIMARY KEY";
+  }
+  if (!field.optional) {
     modifiers += " NOT NULL";
   }
-  if (column.unique) {
+  if (field.unique) {
     modifiers += " UNIQUE";
   }
-  if (hasDefault(column)) {
-    modifiers += ` DEFAULT ${getDefaultValueSql(columnName, column)}`;
+  if (hasDefault(field)) {
+    modifiers += ` DEFAULT ${getDefaultValueSql(fieldName, field)}`;
   }
   return modifiers;
 }
 function hasDefault(field) {
-  return field.default !== void 0;
+  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}`;
+      return `${column.default || "AUTOINCREMENT"}`;
     case "text":
       return sqlite.escapeString(column.default);
     case "date":
@@ -138,7 +167,7 @@ function getDefaultValueSql(columnName, column) {
       try {
         stringified = JSON.stringify(column.default);
       } catch (e) {
-        console.info(
+        console.log(
           `Invalid default value for column ${bold(
             columnName
           )}. Defaults must be valid JSON when using the \`json()\` type.`
@@ -149,9 +178,6 @@ function getDefaultValueSql(columnName, column) {
     }
   }
 }
-function generateId() {
-  return nanoid(12);
-}
 const dateType = customType({
   dataType() {
     return "text";
@@ -174,14 +200,11 @@ const jsonType = customType({
     return JSON.parse(value);
   }
 });
-const initialColumns = {
-  id: text("id").primaryKey().$default(() => generateId())
-};
 function collectionToTable(name, collection, isJsonSerializable = true) {
-  const columns = {
-    // Spread to avoid mutating `initialColumns`
-    ...initialColumns
-  };
+  const columns = {};
+  if (!Object.entries(collection.fields).some(([, field]) => hasPrimaryKey(field))) {
+    columns["_id"] = integer("_id").primaryKey();
+  }
   for (const [fieldName, field] of Object.entries(collection.fields)) {
     columns[fieldName] = columnMapper(fieldName, field, isJsonSerializable);
   }
@@ -195,12 +218,16 @@ function columnMapper(fieldName, field, isJsonSerializable) {
       c = text(fieldName);
       if (field.default !== void 0)
         c = c.default(field.default);
+      if (field.primaryKey === true)
+        c = c.primaryKey();
       break;
     }
     case "number": {
       c = integer(fieldName);
       if (field.default !== void 0)
         c = c.default(field.default);
+      if (field.primaryKey === true)
+        c = c.primaryKey({ autoIncrement: true });
       break;
     }
     case "boolean": {
@@ -246,5 +273,9 @@ export {
   createLocalDatabaseClient,
   createRemoteDatabaseClient,
   getCreateTableQuery,
+  getModifiers,
+  hasDefault,
+  hasPrimaryKey,
+  schemaTypeToSqlType,
   setupDbTables
 };

package/dist/migrations.d.ts

@@ -1,9 +1,12 @@
-import type { DBCollections } from './types.js';
+import type { DBSnapshot } from './types.js';
+import type { AstroConfig } from 'astro';
 export declare function getMigrations(): Promise<string[]>;
 export declare function loadMigration(migration: string): Promise<{
     diff: any[];
     db: string[];
 }>;
-export declare function loadInitialSnapshot(): Promise<DBCollections>;
-export declare function initializeMigrationsDirectory(currentSnapshot: unknown): Promise<void>;
-export declare function initializeFromMigrations(allMigrationFiles: string[]): Promise<DBCollections>;
+export declare function loadInitialSnapshot(): Promise<DBSnapshot>;
+export declare function initializeMigrationsDirectory(currentSnapshot: DBSnapshot): Promise<void>;
+export declare function initializeFromMigrations(allMigrationFiles: string[]): Promise<DBSnapshot>;
+export declare function createCurrentSnapshot(config: AstroConfig): DBSnapshot;
+export declare function createEmptySnapshot(): DBSnapshot;

package/dist/migrations.js

@@ -14,7 +14,14 @@ async function loadMigration(migration) {
   return JSON.parse(await readFile(`./migrations/${migration}`, "utf-8"));
 }
 async function loadInitialSnapshot() {
-  return JSON.parse(await readFile("./migrations/0000_snapshot.json", "utf-8"));
+  const snapshot = JSON.parse(await readFile("./migrations/0000_snapshot.json", "utf-8"));
+  if (snapshot.experimentalVersion === 1) {
+    return snapshot;
+  }
+  if (!snapshot.schema) {
+    return { experimentalVersion: 1, schema: snapshot };
+  }
+  throw new Error("Invalid snapshot format");
 }
 async function initializeMigrationsDirectory(currentSnapshot) {
   await mkdir("./migrations", { recursive: true });
@@ -32,7 +39,16 @@ async function initializeFromMigrations(allMigrationFiles) {
   }
   return prevSnapshot;
 }
+function createCurrentSnapshot(config) {
+  const schema = JSON.parse(JSON.stringify(config.db?.collections ?? {}));
+  return { experimentalVersion: 1, schema };
+}
+function createEmptySnapshot() {
+  return { experimentalVersion: 1, schema: {} };
+}
 export {
+  createCurrentSnapshot,
+  createEmptySnapshot,
   getMigrations,
   initializeFromMigrations,
   initializeMigrationsDirectory,

package/dist/typegen.js

@@ -17,41 +17,24 @@ ${Object.entries(collections).map(([name, collection]) => generateTableType(name
   await writeFile(new URL(DB_TYPES_FILE, dotAstroDir), content);
 }
 function generateTableType(name, collection) {
-  let tableType = `	export const ${name}: import(${INTERNAL_MOD_IMPORT}).AstroTable<{
-		name: ${JSON.stringify(name)};
-		columns: {
-			id: import(${INTERNAL_MOD_IMPORT}).AstroId<{
-				tableName: ${JSON.stringify(name)};
-			}>;`;
-  for (const [fieldName, field] of Object.entries(collection.fields)) {
-    const drizzleInterface = schemaTypeToDrizzleInterface(field.type);
-    tableType += `
-			${fieldName}: import(${INTERNAL_MOD_IMPORT}).${drizzleInterface}<{
-				tableName: ${JSON.stringify(name)};
-				name: ${JSON.stringify(fieldName)};
-				notNull: ${field.optional ? "false" : "true"};
-				hasDefault: ${typeof field.default !== "undefined" ? "true" : "false"};
-			}>;`;
-  }
-  tableType += `
-		};
-	}>;`;
+  let tableType = `	export const ${name}: import(${INTERNAL_MOD_IMPORT}).Table<
+		${JSON.stringify(name)},
+		${JSON.stringify(
+    Object.fromEntries(
+      Object.entries(collection.fields).map(([fieldName, field]) => [
+        fieldName,
+        {
+          // Only select fields Drizzle needs for inference
+          type: field.type,
+          optional: field.optional,
+          default: field.default
+        }
+      ])
+    )
+  )}
+	>;`;
   return tableType;
 }
-function schemaTypeToDrizzleInterface(type) {
-  switch (type) {
-    case "text":
-      return "AstroText";
-    case "number":
-      return "AstroNumber";
-    case "boolean":
-      return "AstroBoolean";
-    case "date":
-      return "AstroDate";
-    case "json":
-      return "AstroJson";
-  }
-}
 export {
   typegen
 };