@astrojs/db 0.9.6 → 0.9.7

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

@@ -38,8 +38,6 @@ export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig> ext
 interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
     on: MaybeArray<Extract<keyof TColumns, string>>;
 }
-/** @deprecated Use `TableConfig` instead */
-export type ResolvedCollectionConfig<TColumns extends ColumnsConfig = ColumnsConfig> = TableConfig<TColumns>;
 export type NumberColumnOpts = z.input<typeof numberColumnOptsSchema>;
 export type TextColumnOpts = z.input<typeof textColumnOptsSchema>;
 export type AstroDbIntegration = AstroIntegration & {

package/dist/core/cli/migration-queries.d.ts

@@ -7,10 +7,10 @@ export declare function getMigrationQueries({ oldSnapshot, newSnapshot, reset, }
     queries: string[];
     confirmations: string[];
 }>;
-export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, }: {
-    collectionName: string;
-    oldCollection: DBTable;
-    newCollection: DBTable;
+export declare function getTableChangeQueries({ tableName, oldTable, newTable, }: {
+    tableName: string;
+    oldTable: DBTable;
+    newTable: DBTable;
 }): Promise<{
     queries: string[];
     confirmations: string[];

package/dist/core/cli/migration-queries.js

@@ -7,6 +7,7 @@ import { hasPrimaryKey } from "../../runtime/index.js";
 import {
   getCreateIndexQueries,
   getCreateTableQuery,
+  getDropTableIfExistsQuery,
   getModifiers,
   getReferencesConfig,
   hasDefault,
@@ -34,84 +35,79 @@ async function getMigrationQueries({
     oldSnapshot = createEmptySnapshot();
     queries.push(...getDropTableQueriesForSnapshot(currentSnapshot));
   }
-  const addedCollections = getAddedCollections(oldSnapshot, newSnapshot);
-  const droppedTables = getDroppedCollections(oldSnapshot, newSnapshot);
+  const addedTables = getAddedTables(oldSnapshot, newSnapshot);
+  const droppedTables = getDroppedTables(oldSnapshot, newSnapshot);
   const notDeprecatedDroppedTables = Object.fromEntries(
     Object.entries(droppedTables).filter(([, table]) => !table.deprecated)
   );
-  if (!isEmpty(addedCollections) && !isEmpty(notDeprecatedDroppedTables)) {
+  if (!isEmpty(addedTables) && !isEmpty(notDeprecatedDroppedTables)) {
     throw new Error(
-      RENAME_TABLE_ERROR(
-        Object.keys(addedCollections)[0],
-        Object.keys(notDeprecatedDroppedTables)[0]
-      )
+      RENAME_TABLE_ERROR(Object.keys(addedTables)[0], Object.keys(notDeprecatedDroppedTables)[0])
     );
   }
-  for (const [collectionName, collection] of Object.entries(addedCollections)) {
-    queries.push(getCreateTableQuery(collectionName, collection));
-    queries.push(...getCreateIndexQueries(collectionName, collection));
+  for (const [tableName, table] of Object.entries(addedTables)) {
+    queries.push(getCreateTableQuery(tableName, table));
+    queries.push(...getCreateIndexQueries(tableName, table));
   }
-  for (const [collectionName] of Object.entries(droppedTables)) {
-    const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
+  for (const [tableName] of Object.entries(droppedTables)) {
+    const dropQuery = `DROP TABLE ${sqlite.escapeName(tableName)}`;
     queries.push(dropQuery);
   }
-  for (const [collectionName, newCollection] of Object.entries(newSnapshot.schema)) {
-    const oldCollection = oldSnapshot.schema[collectionName];
-    if (!oldCollection)
+  for (const [tableName, newTable] of Object.entries(newSnapshot.schema)) {
+    const oldTable = oldSnapshot.schema[tableName];
+    if (!oldTable)
       continue;
-    const addedColumns = getAdded(oldCollection.columns, newCollection.columns);
-    const droppedColumns = getDropped(oldCollection.columns, newCollection.columns);
+    const addedColumns = getAdded(oldTable.columns, newTable.columns);
+    const droppedColumns = getDropped(oldTable.columns, newTable.columns);
     const notDeprecatedDroppedColumns = Object.fromEntries(
       Object.entries(droppedColumns).filter(([, col]) => !col.schema.deprecated)
     );
     if (!isEmpty(addedColumns) && !isEmpty(notDeprecatedDroppedColumns)) {
       throw new Error(
         RENAME_COLUMN_ERROR(
-          `${collectionName}.${Object.keys(addedColumns)[0]}`,
-          `${collectionName}.${Object.keys(notDeprecatedDroppedColumns)[0]}`
+          `${tableName}.${Object.keys(addedColumns)[0]}`,
+          `${tableName}.${Object.keys(notDeprecatedDroppedColumns)[0]}`
         )
       );
     }
-    const result = await getCollectionChangeQueries({
-      collectionName,
-      oldCollection,
-      newCollection
+    const result = await getTableChangeQueries({
+      tableName,
+      oldTable,
+      newTable
     });
     queries.push(...result.queries);
     confirmations.push(...result.confirmations);
   }
   return { queries, confirmations };
 }
-async function getCollectionChangeQueries({
-  collectionName,
-  oldCollection,
-  newCollection
+async function getTableChangeQueries({
+  tableName,
+  oldTable,
+  newTable
 }) {
   const queries = [];
   const confirmations = [];
-  const updated = getUpdatedColumns(oldCollection.columns, newCollection.columns);
-  const added = getAdded(oldCollection.columns, newCollection.columns);
-  const dropped = getDropped(oldCollection.columns, newCollection.columns);
-  const hasForeignKeyChanges = Boolean(
-    deepDiff(oldCollection.foreignKeys, newCollection.foreignKeys)
-  );
+  const updated = getUpdatedColumns(oldTable.columns, newTable.columns);
+  const added = getAdded(oldTable.columns, newTable.columns);
+  const dropped = getDropped(oldTable.columns, newTable.columns);
+  const hasForeignKeyChanges = Boolean(deepDiff(oldTable.foreignKeys, newTable.foreignKeys));
   if (!hasForeignKeyChanges && isEmpty(updated) && isEmpty(added) && isEmpty(dropped)) {
     return {
       queries: getChangeIndexQueries({
-        collectionName,
-        oldIndexes: oldCollection.indexes,
-        newIndexes: newCollection.indexes
+        tableName,
+        oldIndexes: oldTable.indexes,
+        newIndexes: newTable.indexes
       }),
       confirmations
     };
   }
   if (!hasForeignKeyChanges && isEmpty(updated) && Object.values(dropped).every(canAlterTableDropColumn) && Object.values(added).every(canAlterTableAddColumn)) {
     queries.push(
-      ...getAlterTableQueries(collectionName, added, dropped),
+      ...getAlterTableQueries(tableName, added, dropped),
       ...getChangeIndexQueries({
-        collectionName,
-        oldIndexes: oldCollection.indexes,
-        newIndexes: newCollection.indexes
+        tableName,
+        oldIndexes: oldTable.indexes,
+        newIndexes: newTable.indexes
       })
     );
     return { queries, confirmations };
@@ -121,31 +117,31 @@ async function getCollectionChangeQueries({
     const { reason, columnName } = dataLossCheck;
     const reasonMsgs = {
       "added-required": `You added new required column '${color.bold(
-        collectionName + "." + columnName
+        tableName + "." + columnName
       )}' with no default value.
       This cannot be executed on an existing table.`,
       "updated-type": `Updating existing column ${color.bold(
-        collectionName + "." + columnName
+        tableName + "." + columnName
       )} to a new type that cannot be handled automatically.`
     };
     confirmations.push(reasonMsgs[reason]);
   }
-  const primaryKeyExists = Object.entries(newCollection.columns).find(
+  const primaryKeyExists = Object.entries(newTable.columns).find(
     ([, column]) => hasPrimaryKey(column)
   );
   const droppedPrimaryKey = Object.entries(dropped).find(([, column]) => hasPrimaryKey(column));
   const recreateTableQueries = getRecreateTableQueries({
-    collectionName,
-    newCollection,
+    tableName,
+    newTable,
     added,
     hasDataLoss: dataLossCheck.dataLoss,
     migrateHiddenPrimaryKey: !primaryKeyExists && !droppedPrimaryKey
   });
-  queries.push(...recreateTableQueries, ...getCreateIndexQueries(collectionName, newCollection));
+  queries.push(...recreateTableQueries, ...getCreateIndexQueries(tableName, newTable));
   return { queries, confirmations };
 }
 function getChangeIndexQueries({
-  collectionName,
+  tableName,
   oldIndexes = {},
   newIndexes = {}
 }) {
@@ -159,32 +155,32 @@ function getChangeIndexQueries({
     const dropQuery = `DROP INDEX ${sqlite.escapeName(indexName)}`;
     queries.push(dropQuery);
   }
-  queries.push(...getCreateIndexQueries(collectionName, { indexes: added }));
+  queries.push(...getCreateIndexQueries(tableName, { indexes: added }));
   return queries;
 }
-function getAddedCollections(oldCollections, newCollections) {
+function getAddedTables(oldTables, newTables) {
   const added = {};
-  for (const [key, newCollection] of Object.entries(newCollections.schema)) {
-    if (!(key in oldCollections.schema))
-      added[key] = newCollection;
+  for (const [key, newTable] of Object.entries(newTables.schema)) {
+    if (!(key in oldTables.schema))
+      added[key] = newTable;
   }
   return added;
 }
-function getDroppedCollections(oldCollections, newCollections) {
+function getDroppedTables(oldTables, newTables) {
   const dropped = {};
-  for (const [key, oldCollection] of Object.entries(oldCollections.schema)) {
-    if (!(key in newCollections.schema))
-      dropped[key] = oldCollection;
+  for (const [key, oldTable] of Object.entries(oldTables.schema)) {
+    if (!(key in newTables.schema))
+      dropped[key] = oldTable;
   }
   return dropped;
 }
-function getAlterTableQueries(unescapedCollectionName, added, dropped) {
+function getAlterTableQueries(unescTableName, added, dropped) {
   const queries = [];
-  const collectionName = sqlite.escapeName(unescapedCollectionName);
+  const tableName = sqlite.escapeName(unescTableName);
   for (const [unescColumnName, column] of Object.entries(added)) {
     const columnName = sqlite.escapeName(unescColumnName);
     const type = schemaTypeToSqlType(column.type);
-    const q = `ALTER TABLE ${collectionName} ADD COLUMN ${columnName} ${type}${getModifiers(
+    const q = `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${type}${getModifiers(
       columnName,
       column
     )}`;
@@ -192,37 +188,34 @@ function getAlterTableQueries(unescapedCollectionName, added, dropped) {
   }
   for (const unescColumnName of Object.keys(dropped)) {
     const columnName = sqlite.escapeName(unescColumnName);
-    const q = `ALTER TABLE ${collectionName} DROP COLUMN ${columnName}`;
+    const q = `ALTER TABLE ${tableName} DROP COLUMN ${columnName}`;
     queries.push(q);
   }
   return queries;
 }
 function getRecreateTableQueries({
-  collectionName: unescCollectionName,
-  newCollection,
+  tableName: unescTableName,
+  newTable,
   added,
   hasDataLoss,
   migrateHiddenPrimaryKey
 }) {
-  const unescTempName = `${unescCollectionName}_${genTempTableName()}`;
+  const unescTempName = `${unescTableName}_${genTempTableName()}`;
   const tempName = sqlite.escapeName(unescTempName);
-  const collectionName = sqlite.escapeName(unescCollectionName);
+  const tableName = sqlite.escapeName(unescTableName);
   if (hasDataLoss) {
-    return [
-      `DROP TABLE ${collectionName}`,
-      getCreateTableQuery(unescCollectionName, newCollection)
-    ];
+    return [`DROP TABLE ${tableName}`, getCreateTableQuery(unescTableName, newTable)];
   }
-  const newColumns = [...Object.keys(newCollection.columns)];
+  const newColumns = [...Object.keys(newTable.columns)];
   if (migrateHiddenPrimaryKey) {
     newColumns.unshift("_id");
   }
   const escapedColumns = newColumns.filter((i) => !(i in added)).map((c) => sqlite.escapeName(c)).join(", ");
   return [
-    getCreateTableQuery(unescTempName, newCollection),
-    `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${collectionName}`,
-    `DROP TABLE ${collectionName}`,
-    `ALTER TABLE ${tempName} RENAME TO ${collectionName}`
+    getCreateTableQuery(unescTempName, newTable),
+    `INSERT INTO ${tempName} (${escapedColumns}) SELECT ${escapedColumns} FROM ${tableName}`,
+    `DROP TABLE ${tableName}`,
+    `ALTER TABLE ${tempName} RENAME TO ${tableName}`
   ];
 }
 function isEmpty(obj) {
@@ -354,8 +347,8 @@ async function getProductionCurrentSnapshot({
 }
 function getDropTableQueriesForSnapshot(snapshot) {
   const queries = [];
-  for (const collectionName of Object.keys(snapshot.schema)) {
-    const dropQuery = `DROP TABLE ${sqlite.escapeName(collectionName)}`;
+  for (const tableName of Object.keys(snapshot.schema)) {
+    const dropQuery = getDropTableIfExistsQuery(tableName);
     queries.unshift(dropQuery);
   }
   return queries;
@@ -387,7 +380,7 @@ export {
   createCurrentSnapshot,
   createEmptySnapshot,
   formatDataLossMessage,
-  getCollectionChangeQueries,
   getMigrationQueries,
-  getProductionCurrentSnapshot
+  getProductionCurrentSnapshot,
+  getTableChangeQueries
 };

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

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

package/dist/core/integration/typegen.js

@@ -9,7 +9,7 @@ async function typegen(astroConfig) {
 async function typegenInternal({ tables, root }) {
   const content = `// This file is generated by Astro DB
 declare module 'astro:db' {
-${Object.entries(tables).map(([name, collection]) => generateTableType(name, collection)).join("\n")}
+${Object.entries(tables).map(([name, table]) => generateTableType(name, table)).join("\n")}
 }
 `;
   const dotAstroDir = new URL(".astro/", root);
@@ -18,8 +18,8 @@ ${Object.entries(tables).map(([name, collection]) => generateTableType(name, col
   }
   await writeFile(new URL(DB_TYPES_FILE, dotAstroDir), content);
 }
-function generateTableType(name, collection) {
-  const sanitizedColumnsList = Object.entries(collection.columns).filter(([, val]) => !val.schema.deprecated);
+function generateTableType(name, table) {
+  const sanitizedColumnsList = Object.entries(table.columns).filter(([, val]) => !val.schema.deprecated);
   const sanitizedColumns = Object.fromEntries(sanitizedColumnsList);
   let tableType = `	export const ${name}: import(${RUNTIME_IMPORT}).Table<
 		${JSON.stringify(name)},

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

@@ -91,7 +91,7 @@ ${shouldSeed ? `await seedLocal({
 
 export * from ${RUNTIME_CONFIG_IMPORT};
 
-${getStringifiedCollectionExports(tables)}`;
+${getStringifiedTableExports(tables)}`;
 }
 function getStudioVirtualModContents({
   tables,
@@ -116,13 +116,13 @@ export const db = await createRemoteDatabaseClient(${appTokenArg()}, ${dbUrlArg(
 
 export * from ${RUNTIME_CONFIG_IMPORT};
 
-${getStringifiedCollectionExports(tables)}
+${getStringifiedTableExports(tables)}
 	`;
 }
-function getStringifiedCollectionExports(tables) {
+function getStringifiedTableExports(tables) {
   return Object.entries(tables).map(
-    ([name, collection]) => `export const ${name} = asDrizzleTable(${JSON.stringify(name)}, ${JSON.stringify(
-      collection
+    ([name, table]) => `export const ${name} = asDrizzleTable(${JSON.stringify(name)}, ${JSON.stringify(
+      table
     )}, false)`
   ).join("\n");
 }

package/dist/core/schemas.js

@@ -15,9 +15,9 @@ const baseColumnSchema = z.object({
   optional: z.boolean().optional().default(false),
   unique: z.boolean().optional().default(false),
   deprecated: z.boolean().optional().default(false),
-  // Defined when `defineReadableTable()` is called
+  // Defined when `defineDb()` is called to resolve `references`
   name: z.string().optional(),
-  // TODO: rename to `tableName`. Breaking schema change
+  // TODO: Update to `table`. Will need migration file version change
   collection: z.string().optional()
 });
 const booleanColumnSchema = z.object({

package/dist/core/types.d.ts

@@ -38,8 +38,6 @@ export interface TableConfig<TColumns extends ColumnsConfig = ColumnsConfig> ext
 interface IndexConfig<TColumns extends ColumnsConfig> extends z.input<typeof indexSchema> {
     on: MaybeArray<Extract<keyof TColumns, string>>;
 }
-/** @deprecated Use `TableConfig` instead */
-export type ResolvedCollectionConfig<TColumns extends ColumnsConfig = ColumnsConfig> = TableConfig<TColumns>;
 export type NumberColumnOpts = z.input<typeof numberColumnOptsSchema>;
 export type TextColumnOpts = z.input<typeof textColumnOptsSchema>;
 export type AstroDbIntegration = AstroIntegration & {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { ResolvedCollectionConfig, TableConfig } from './core/types.js';
+export type { 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "description": "",
   "license": "MIT",
   "type": "module",