@astrojs/db 0.3.5 → 0.4.0

package/dist/core/types.js

@@ -11,25 +11,25 @@ const sqlSchema = z.instanceof(SQL).transform(
     sql: sqlite.sqlToQuery(sqlObj).sql
   })
 );
-const baseFieldSchema = z.object({
+const baseColumnSchema = z.object({
   label: z.string().optional(),
   optional: z.boolean().optional().default(false),
   unique: z.boolean().optional().default(false),
-  // Defined when `defineCollection()` is called
+  // Defined when `defineReadableTable()` is called
   name: z.string().optional(),
   collection: z.string().optional()
 });
-const booleanFieldSchema = z.object({
+const booleanColumnSchema = z.object({
   type: z.literal("boolean"),
-  schema: baseFieldSchema.extend({
+  schema: baseColumnSchema.extend({
     default: z.union([z.boolean(), sqlSchema]).optional()
   })
 });
-const numberFieldBaseSchema = baseFieldSchema.omit({ optional: true }).and(
+const numberColumnBaseSchema = baseColumnSchema.omit({ optional: true }).and(
   z.union([
     z.object({
       primaryKey: z.literal(false).optional().default(false),
-      optional: baseFieldSchema.shape.optional,
+      optional: baseColumnSchema.shape.optional,
       default: z.union([z.number(), sqlSchema]).optional()
     }),
     z.object({
@@ -42,23 +42,23 @@ const numberFieldBaseSchema = baseFieldSchema.omit({ optional: true }).and(
     })
   ])
 );
-const numberFieldOptsSchema = numberFieldBaseSchema.and(
+const numberColumnOptsSchema = numberColumnBaseSchema.and(
   z.object({
-    references: z.function().returns(z.lazy(() => numberFieldSchema)).optional().transform((fn) => fn?.())
+    references: z.function().returns(z.lazy(() => numberColumnSchema)).optional().transform((fn) => fn?.())
   })
 );
-const numberFieldSchema = z.object({
+const numberColumnSchema = z.object({
   type: z.literal("number"),
-  schema: numberFieldOptsSchema
+  schema: numberColumnOptsSchema
 });
-const textFieldBaseSchema = baseFieldSchema.omit({ optional: true }).extend({
+const textColumnBaseSchema = baseColumnSchema.omit({ optional: true }).extend({
   default: z.union([z.string(), sqlSchema]).optional(),
   multiline: z.boolean().optional()
 }).and(
   z.union([
     z.object({
       primaryKey: z.literal(false).optional().default(false),
-      optional: baseFieldSchema.shape.optional
+      optional: baseColumnSchema.shape.optional
     }),
     z.object({
       // text primary key allows NULL values.
@@ -70,18 +70,18 @@ const textFieldBaseSchema = baseFieldSchema.omit({ optional: true }).extend({
     })
   ])
 );
-const textFieldOptsSchema = textFieldBaseSchema.and(
+const textColumnOptsSchema = textColumnBaseSchema.and(
   z.object({
-    references: z.function().returns(z.lazy(() => textFieldSchema)).optional().transform((fn) => fn?.())
+    references: z.function().returns(z.lazy(() => textColumnSchema)).optional().transform((fn) => fn?.())
   })
 );
-const textFieldSchema = z.object({
+const textColumnSchema = z.object({
   type: z.literal("text"),
-  schema: textFieldOptsSchema
+  schema: textColumnOptsSchema
 });
-const dateFieldSchema = z.object({
+const dateColumnSchema = z.object({
   type: z.literal("date"),
-  schema: baseFieldSchema.extend({
+  schema: baseColumnSchema.extend({
     default: z.union([
       sqlSchema,
       // transform to ISO string for serialization
@@ -89,31 +89,31 @@ const dateFieldSchema = z.object({
     ]).optional()
   })
 });
-const jsonFieldSchema = z.object({
+const jsonColumnSchema = z.object({
   type: z.literal("json"),
-  schema: baseFieldSchema.extend({
+  schema: baseColumnSchema.extend({
     default: z.unknown().optional()
   })
 });
-const fieldSchema = z.union([
-  booleanFieldSchema,
-  numberFieldSchema,
-  textFieldSchema,
-  dateFieldSchema,
-  jsonFieldSchema
+const columnSchema = z.union([
+  booleanColumnSchema,
+  numberColumnSchema,
+  textColumnSchema,
+  dateColumnSchema,
+  jsonColumnSchema
 ]);
-const referenceableFieldSchema = z.union([textFieldSchema, numberFieldSchema]);
-const fieldsSchema = z.record(fieldSchema);
+const referenceableColumnSchema = z.union([textColumnSchema, numberColumnSchema]);
+const columnsSchema = z.record(columnSchema);
 const indexSchema = z.object({
   on: z.string().or(z.array(z.string())),
   unique: z.boolean().optional()
 });
 const foreignKeysSchema = z.object({
-  fields: z.string().or(z.array(z.string())),
-  references: z.function().returns(z.lazy(() => referenceableFieldSchema.or(z.array(referenceableFieldSchema)))).transform((fn) => fn())
+  columns: z.string().or(z.array(z.string())),
+  references: z.function().returns(z.lazy(() => referenceableColumnSchema.or(z.array(referenceableColumnSchema)))).transform((fn) => fn())
 });
 const baseCollectionSchema = z.object({
-  fields: fieldsSchema,
+  columns: columnsSchema,
   indexes: z.record(indexSchema).optional(),
   foreignKeys: z.array(foreignKeysSchema).optional()
 });
@@ -124,17 +124,17 @@ const writableCollectionSchema = baseCollectionSchema.extend({
   writable: z.literal(true)
 });
 const collectionSchema = z.union([readableCollectionSchema, writableCollectionSchema]);
-const collectionsSchema = z.preprocess((rawCollections) => {
-  const collections = z.record(z.any()).parse(rawCollections, { errorMap });
-  for (const [collectionName, collection] of Object.entries(collections)) {
+const tablesSchema = z.preprocess((rawCollections) => {
+  const tables = z.record(z.any()).parse(rawCollections, { errorMap });
+  for (const [collectionName, collection] of Object.entries(tables)) {
     collection.table = collectionToTable(
       collectionName,
       collectionSchema.parse(collection, { errorMap })
     );
-    const { fields } = z.object({ fields: z.record(z.any()) }).parse(collection, { errorMap });
-    for (const [fieldName, field2] of Object.entries(fields)) {
-      field2.schema.name = fieldName;
-      field2.schema.collection = collectionName;
+    const { columns } = z.object({ columns: z.record(z.any()) }).parse(collection, { errorMap });
+    for (const [columnName, column2] of Object.entries(columns)) {
+      column2.schema.name = columnName;
+      column2.schema.collection = collectionName;
     }
   }
   return rawCollections;
@@ -142,10 +142,11 @@ const collectionsSchema = z.preprocess((rawCollections) => {
 function defineData(fn) {
   return fn;
 }
+const dbDataFn = z.function().returns(z.union([z.void(), z.promise(z.void())]));
 const dbConfigSchema = z.object({
   studio: z.boolean().optional(),
-  collections: collectionsSchema.optional(),
-  data: z.function().returns(z.union([z.void(), z.promise(z.void())])).optional(),
+  tables: tablesSchema.optional(),
+  data: z.union([dbDataFn, z.array(dbDataFn)]).optional(),
   unsafeWritable: z.boolean().optional().default(false)
 });
 const astroConfigWithDbSchema = z.object({
@@ -159,13 +160,13 @@ function baseDefineCollection(userConfig, writable) {
     table: null
   };
 }
-function defineCollection(userConfig) {
+function defineReadableTable(userConfig) {
   return baseDefineCollection(userConfig, false);
 }
-function defineWritableCollection(userConfig) {
+function defineWritableTable(userConfig) {
   return baseDefineCollection(userConfig, true);
 }
-function createField(type, schema) {
+function createColumn(type, schema) {
   return {
     type,
     /**
@@ -174,35 +175,35 @@ function createField(type, schema) {
     schema
   };
 }
-const field = {
+const column = {
   number: (opts = {}) => {
-    return createField("number", opts);
+    return createColumn("number", opts);
   },
   boolean: (opts = {}) => {
-    return createField("boolean", opts);
+    return createColumn("boolean", opts);
   },
   text: (opts = {}) => {
-    return createField("text", opts);
+    return createColumn("text", opts);
   },
   date(opts = {}) {
-    return createField("date", opts);
+    return createColumn("date", opts);
   },
   json(opts = {}) {
-    return createField("json", opts);
+    return createColumn("json", opts);
   }
 };
 export {
   astroConfigWithDbSchema,
   collectionSchema,
-  collectionsSchema,
+  column,
+  columnSchema,
   dbConfigSchema,
-  defineCollection,
   defineData,
-  defineWritableCollection,
-  field,
-  fieldSchema,
+  defineReadableTable,
+  defineWritableTable,
   indexSchema,
   readableCollectionSchema,
-  referenceableFieldSchema,
+  referenceableColumnSchema,
+  tablesSchema,
   writableCollectionSchema
 };

package/dist/core/utils.js

@@ -5,7 +5,7 @@ function getAstroStudioEnv(envMode = "") {
 }
 function getRemoteDatabaseUrl() {
   const env = getAstroStudioEnv();
-  return env.ASTRO_STUDIO_REMOTE_DB_URL || "https://studio-gateway.fly.dev";
+  return env.ASTRO_STUDIO_REMOTE_DB_URL || "https://db.services.astro.build";
 }
 function getAstroStudioUrl() {
   const env = getAstroStudioEnv();

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { defineCollection, defineWritableCollection, defineData, field } from './core/types.js';
+export { defineReadableTable, defineWritableTable, defineData, column } from './core/types.js';
 export type { ResolvedCollectionConfig, DBDataContext } from './core/types.js';
 export { cli } from './core/cli/index.js';
 export { integration as default } from './core/integration/index.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { defineCollection, defineWritableCollection, defineData, field } from "./core/types.js";
+import { defineReadableTable, defineWritableTable, defineData, column } from "./core/types.js";
 import { cli } from "./core/cli/index.js";
 import { integration } from "./core/integration/index.js";
 import { sql, NOW, TRUE, FALSE } from "./runtime/index.js";
@@ -7,10 +7,10 @@ export {
   NOW,
   TRUE,
   cli,
+  column,
   integration as default,
-  defineCollection,
   defineData,
-  defineWritableCollection,
-  field,
+  defineReadableTable,
+  defineWritableTable,
   sql
 };

package/dist/runtime/db-client.d.ts

@@ -1,7 +1,12 @@
-import { type DBCollections } from '../core/types.js';
-export declare function createLocalDatabaseClient({ collections, dbUrl, seeding, }: {
+/// <reference types="node" resolution-mode="require"/>
+import { type DBTables } from '../core/types.js';
+import type { LibSQLDatabase } from 'drizzle-orm/libsql';
+interface LocalDatabaseClient extends LibSQLDatabase, Disposable {
+}
+export declare function createLocalDatabaseClient({ tables, dbUrl, seeding, }: {
     dbUrl: string;
-    collections: DBCollections;
+    tables: DBTables;
     seeding: boolean;
-}): Promise<import("drizzle-orm/libsql").LibSQLDatabase<Record<string, never>>>;
+}): Promise<LocalDatabaseClient>;
 export declare function createRemoteDatabaseClient(appToken: string, remoteDbURL: string): import("drizzle-orm/sqlite-proxy").SqliteRemoteDatabase<Record<string, never>>;
+export {};

package/dist/runtime/db-client.js

@@ -7,34 +7,38 @@ import { z } from "zod";
 import { getTableName } from "drizzle-orm";
 const isWebContainer = !!process.versions?.webcontainer;
 async function createLocalDatabaseClient({
-  collections,
+  tables,
   dbUrl,
   seeding
 }) {
   const url = isWebContainer ? "file:content.db" : dbUrl;
   const client = createClient({ url });
-  const db = drizzleLibsql(client);
+  const db = Object.assign(drizzleLibsql(client), {
+    [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
+      client.close();
+    }
+  });
   if (seeding)
     return db;
   const { insert: drizzleInsert, update: drizzleUpdate, delete: drizzleDelete } = db;
   return Object.assign(db, {
     insert(Table) {
-      checkIfModificationIsAllowed(collections, Table);
+      checkIfModificationIsAllowed(tables, Table);
       return drizzleInsert.call(this, Table);
     },
     update(Table) {
-      checkIfModificationIsAllowed(collections, Table);
+      checkIfModificationIsAllowed(tables, Table);
       return drizzleUpdate.call(this, Table);
     },
     delete(Table) {
-      checkIfModificationIsAllowed(collections, Table);
+      checkIfModificationIsAllowed(tables, Table);
       return drizzleDelete.call(this, Table);
     }
   });
 }
-function checkIfModificationIsAllowed(collections, Table) {
+function checkIfModificationIsAllowed(tables, Table) {
   const tableName = getTableName(Table);
-  const collection = collections[tableName];
+  const collection = tables[tableName];
   if (!collection.writable) {
     throw new Error(`The [${tableName}] collection is read-only.`);
   }

package/dist/runtime/index.d.ts

@@ -1,15 +1,15 @@
 import type { SqliteRemoteDatabase } from 'drizzle-orm/sqlite-proxy';
-import { type DBCollection, type DBField } from '../core/types.js';
-import { type ColumnDataType, sql, SQL } from 'drizzle-orm';
+import { type DBTable, type DBColumn } from '../core/types.js';
+import { type ColumnDataType, sql } from 'drizzle-orm';
 export { sql };
 export type SqliteDB = SqliteRemoteDatabase;
 export type { Table } from './types.js';
 export { createRemoteDatabaseClient, createLocalDatabaseClient } from './db-client.js';
-export declare function hasPrimaryKey(field: DBField): boolean;
-export declare const NOW: SQL<unknown>;
-export declare const TRUE: SQL<unknown>;
-export declare const FALSE: SQL<unknown>;
-export declare function collectionToTable(name: string, collection: DBCollection): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+export declare function hasPrimaryKey(column: DBColumn): boolean;
+export declare const NOW: import("drizzle-orm").SQL<unknown>;
+export declare const TRUE: import("drizzle-orm").SQL<unknown>;
+export declare const FALSE: import("drizzle-orm").SQL<unknown>;
+export declare function collectionToTable(name: string, collection: DBTable): import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: string;
     schema: undefined;
     columns: {

package/dist/runtime/index.js

@@ -1,5 +1,5 @@
 import {} from "../core/types.js";
-import { sql, SQL } from "drizzle-orm";
+import { sql } from "drizzle-orm";
 import {
   customType,
   integer,
@@ -7,11 +7,10 @@ import {
   text,
   index
 } from "drizzle-orm/sqlite-core";
-import { z } from "zod";
 import { isSerializedSQL } from "./types.js";
 import { createRemoteDatabaseClient, createLocalDatabaseClient } from "./db-client.js";
-function hasPrimaryKey(field) {
-  return "primaryKey" in field.schema && !!field.schema.primaryKey;
+function hasPrimaryKey(column) {
+  return "primaryKey" in column.schema && !!column.schema.primaryKey;
 }
 const NOW = sql`CURRENT_TIMESTAMP`;
 const TRUE = sql`TRUE`;
@@ -24,7 +23,6 @@ const dateType = customType({
     return value.toISOString();
   },
   fromDriver(value) {
-    console.log("driver", value);
     return new Date(value);
   }
 });
@@ -41,11 +39,11 @@ const jsonType = customType({
 });
 function collectionToTable(name, collection) {
   const columns = {};
-  if (!Object.entries(collection.fields).some(([, field]) => hasPrimaryKey(field))) {
+  if (!Object.entries(collection.columns).some(([, column]) => hasPrimaryKey(column))) {
     columns["_id"] = integer("_id").primaryKey();
   }
-  for (const [fieldName, field] of Object.entries(collection.fields)) {
-    columns[fieldName] = columnMapper(fieldName, field);
+  for (const [columnName, column] of Object.entries(collection.columns)) {
+    columns[columnName] = columnMapper(columnName, column);
   }
   const table = sqliteTable(name, columns, (ormTable) => {
     const indexes = {};
@@ -63,48 +61,48 @@ function collectionToTable(name, collection) {
 function atLeastOne(arr) {
   return arr.length > 0;
 }
-function columnMapper(fieldName, field) {
+function columnMapper(columnName, column) {
   let c;
-  switch (field.type) {
+  switch (column.type) {
     case "text": {
-      c = text(fieldName);
-      if (field.schema.default !== void 0)
-        c = c.default(handleSerializedSQL(field.schema.default));
-      if (field.schema.primaryKey === true)
+      c = text(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      if (column.schema.primaryKey === true)
         c = c.primaryKey();
       break;
     }
     case "number": {
-      c = integer(fieldName);
-      if (field.schema.default !== void 0)
-        c = c.default(handleSerializedSQL(field.schema.default));
-      if (field.schema.primaryKey === true)
+      c = integer(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
+      if (column.schema.primaryKey === true)
         c = c.primaryKey();
       break;
     }
     case "boolean": {
-      c = integer(fieldName, { mode: "boolean" });
-      if (field.schema.default !== void 0)
-        c = c.default(handleSerializedSQL(field.schema.default));
+      c = integer(columnName, { mode: "boolean" });
+      if (column.schema.default !== void 0)
+        c = c.default(handleSerializedSQL(column.schema.default));
       break;
     }
     case "json":
-      c = jsonType(fieldName);
-      if (field.schema.default !== void 0)
-        c = c.default(field.schema.default);
+      c = jsonType(columnName);
+      if (column.schema.default !== void 0)
+        c = c.default(column.schema.default);
       break;
     case "date": {
-      c = dateType(fieldName);
-      if (field.schema.default !== void 0) {
-        const def = handleSerializedSQL(field.schema.default);
+      c = dateType(columnName);
+      if (column.schema.default !== void 0) {
+        const def = handleSerializedSQL(column.schema.default);
         c = c.default(typeof def === "string" ? new Date(def) : def);
       }
       break;
     }
   }
-  if (!field.schema.optional)
+  if (!column.schema.optional)
     c = c.notNull();
-  if (field.schema.unique)
+  if (column.schema.unique)
     c = c.unique();
   return c;
 }

package/dist/runtime/types.d.ts

@@ -1,6 +1,6 @@
 import type { ColumnDataType, ColumnBaseConfig } from 'drizzle-orm';
 import type { SQLiteColumn, SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
-import type { DBField, FieldsConfig } from '../core/types.js';
+import type { DBColumn, ColumnsConfig } 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;
@@ -42,21 +42,21 @@ export type AstroJson<T extends GeneratedConfig<'custom'>> = SQLiteColumn<T & {
     enumValues: never;
     baseColumn: never;
 }>;
-export type Column<T extends DBField['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, TFields extends FieldsConfig> = SQLiteTableWithColumns<{
+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<{
     name: TTableName;
     schema: undefined;
     dialect: 'sqlite';
     columns: {
-        [K in Extract<keyof TFields, string>]: Column<TFields[K]['type'], {
+        [K in Extract<keyof TColumns, string>]: Column<TColumns[K]['type'], {
             tableName: TTableName;
             name: K;
-            hasDefault: TFields[K]['schema'] extends {
+            hasDefault: TColumns[K]['schema'] extends {
                 default: NonNullable<unknown>;
-            } ? true : TFields[K]['schema'] extends {
+            } ? true : TColumns[K]['schema'] extends {
                 primaryKey: true;
             } ? true : false;
-            notNull: TFields[K]['schema']['optional'] extends true ? false : true;
+            notNull: TColumns[K]['schema']['optional'] extends true ? false : true;
         }>;
     };
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/db",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "",
   "license": "MIT",
   "type": "module",
@@ -12,7 +12,6 @@
       "types": "./index.d.ts",
       "import": "./dist/index.js"
     },
-    "./components": "./components/index.ts",
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
@@ -39,8 +38,7 @@
   "files": [
     "index.d.ts",
     "config-augment.d.ts",
-    "dist",
-    "components"
+    "dist"
   ],
   "keywords": [
     "withastro",
@@ -70,7 +68,7 @@
     "mocha": "^10.2.0",
     "typescript": "^5.2.2",
     "vite": "^4.4.11",
-    "astro": "4.4.0",
+    "astro": "4.4.4",
     "astro-scripts": "0.0.14"
   },
   "scripts": {

package/components/Renderer.astro

@@ -1,14 +0,0 @@
----
-import { Renderer as MarkdocRenderer } from '@astrojs/markdoc/components';
-import { Markdoc } from '@astrojs/markdoc/config';
-
-interface Props {
-	content: string;
-}
-
-const { content } = Astro.props;
-
-const ast = Markdoc.parse(content);
----
-
-<MarkdocRenderer stringifiedAst={JSON.stringify(ast)} config={{}} />

package/components/astro-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="astro/client" />

package/components/index.ts

@@ -1,2 +0,0 @@
-// @ts-expect-error: missing types
-export { default as Renderer } from './Renderer.astro';

package/components/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "astro/tsconfigs/strict",
-  "include": ["."],
-  "compilerOptions": {
-    "strictNullChecks": true
-  }
-}

package/dist/cli/commands/push/index.d.ts

@@ -1,6 +0,0 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cmd({ config, flags }: {
-    config: AstroConfig;
-    flags: Arguments;
-}): Promise<void>;

package/dist/cli/commands/shell/index.d.ts

@@ -1,6 +0,0 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cmd({ config, flags }: {
-    config: AstroConfig;
-    flags: Arguments;
-}): Promise<void>;

package/dist/cli/commands/sync/index.d.ts

@@ -1,6 +0,0 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cmd({ config }: {
-    config: AstroConfig;
-    flags: Arguments;
-}): Promise<void>;

package/dist/cli/commands/verify/index.d.ts

@@ -1,6 +0,0 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cmd({ config }: {
-    config: AstroConfig;
-    flags: Arguments;
-}): Promise<void>;

package/dist/cli/index.d.ts

@@ -1,6 +0,0 @@
-import type { AstroConfig } from 'astro';
-import type { Arguments } from 'yargs-parser';
-export declare function cli({ flags, config }: {
-    flags: Arguments;
-    config: AstroConfig;
-}): Promise<void>;

package/dist/cli/queries.d.ts

@@ -1,18 +0,0 @@
-import type { DBCollection, DBSnapshot } from '../types.js';
-interface PromptResponses {
-    allowDataLoss: boolean;
-    columnRenames: Record<string, string | false>;
-    collectionRenames: Record<string, string | false>;
-}
-export declare function getMigrationQueries({ oldSnapshot, newSnapshot, promptResponses, }: {
-    oldSnapshot: DBSnapshot;
-    newSnapshot: DBSnapshot;
-    promptResponses?: PromptResponses;
-}): Promise<string[]>;
-export declare function getCollectionChangeQueries({ collectionName, oldCollection, newCollection, promptResponses, }: {
-    collectionName: string;
-    oldCollection: DBCollection;
-    newCollection: DBCollection;
-    promptResponses?: PromptResponses;
-}): Promise<string[]>;
-export {};

package/dist/cli/seed.d.ts

@@ -1,6 +0,0 @@
-import type { DBCollections } from 'circle-rhyme-yes-measure';
-export declare function seed({ collections, projectId, appToken, }: {
-    collections: DBCollections;
-    projectId: string;
-    appToken: string;
-}): Promise<void>;