nextly 0.0.1 → 0.0.2-alpha.0

package/dist/database/index.d.ts

@@ -0,0 +1,12 @@
+export { A as AdapterConfig, a as AdapterType, D as DbError, b as DbErrorKind, H as HealthCheckResult, i as checkAdapterHealth, j as createAdapter, k as createAdapterFromEnv, o as env, p as getDialectTables, q as healthCheck, r as isDbError, s as schema, t as toDbError, v as validateDatabaseEnv, w as withDbErrors } from '../_dts-chunks/index.d-axCAzZ7m.d.ts';
+import 'drizzle-orm';
+import 'drizzle-orm/pg-core';
+import '../_dts-chunks/collections-handler.d-DjgO74Wt.d.ts';
+import '@nextlyhq/adapter-drizzle';
+import '@nextlyhq/adapter-drizzle/types';
+import 'react';
+import '../_dts-chunks/media.d-DjDOZo4B.d.ts';
+import 'zod';
+import '../_dts-chunks/image-processor.d-OO1PmMrv.d.ts';
+import 'drizzle-orm/mysql-core';
+import 'drizzle-orm/sqlite-core';

package/dist/database/index.mjs

@@ -0,0 +1,40 @@
+import {
+  getDialectTables,
+  schema_exports,
+  withDbErrors
+} from "../chunk-TS7GHTG2.mjs";
+import "../chunk-H26B4FYG.mjs";
+import {
+  checkAdapterHealth,
+  createAdapter,
+  createAdapterFromEnv,
+  validateDatabaseEnv
+} from "../chunk-DP3G27G5.mjs";
+import "../chunk-DV6WVX2Q.mjs";
+import {
+  env
+} from "../chunk-UJ2IMJ4W.mjs";
+import {
+  healthCheck
+} from "../chunk-LAZXX4HR.mjs";
+import "../chunk-D5HQBNUB.mjs";
+import {
+  DbError,
+  isDbError,
+  toDbError
+} from "../chunk-NRUWQ5Z7.mjs";
+import "../chunk-7P6ASYW6.mjs";
+export {
+  DbError,
+  checkAdapterHealth,
+  createAdapter,
+  createAdapterFromEnv,
+  env,
+  getDialectTables,
+  healthCheck,
+  isDbError,
+  schema_exports as schema,
+  toDbError,
+  validateDatabaseEnv,
+  withDbErrors
+};

package/dist/database/seeders/index.d.ts

@@ -0,0 +1,93 @@
+import { DrizzleAdapter } from '@nextlyhq/adapter-drizzle';
+
+/**
+ * Re-export the existing seeder logic from scripts
+ * This module provides a programmatic API for the seed script
+ */
+
+/**
+ * Type for adapters that support getDrizzle() method
+ */
+type AdapterWithDrizzle$2 = {
+    getDrizzle(schema?: Record<string, unknown>): unknown;
+    dialect: string;
+};
+interface SeederResult {
+    success: boolean;
+    created: number;
+    skipped: number;
+    errors: number;
+    total: number;
+    errorMessages?: string[];
+}
+/**
+ * Seed CRUD permissions for core resources
+ * This is the programmatic version of scripts/seed-permissions.ts
+ *
+ * @param adapter - Database adapter instance
+ * @param options - Optional configuration
+ * @returns Promise<SeederResult>
+ *
+ * @example
+ * ```typescript
+ * const result = await seedPermissions(adapter, { silent: true });
+ * if (result.success) {
+ *   console.log(`Created ${result.created} permissions`);
+ * }
+ * ```
+ */
+declare function seedPermissions(adapter: DrizzleAdapter | AdapterWithDrizzle$2, options?: {
+    resources?: readonly string[];
+    actions?: readonly string[];
+    silent?: boolean;
+}): Promise<SeederResult>;
+
+/**
+ * Type for adapters that support getDrizzle() method
+ */
+type AdapterWithDrizzle$1 = {
+    getDrizzle(schema?: Record<string, unknown>): unknown;
+    dialect: string;
+};
+declare function seedSuperAdmin(adapter: DrizzleAdapter | AdapterWithDrizzle$1, options?: {
+    email?: string;
+    password?: string;
+    name?: string;
+    silent?: boolean;
+}): Promise<SeederResult>;
+
+/**
+ * Type for adapters that support getDrizzle() method
+ */
+type AdapterWithDrizzle = {
+    getDrizzle(): unknown;
+    dialect: string;
+};
+
+/**
+ * Run the system bootstrap seeders: permissions and (optionally) the
+ * discovers or runs a user-provided `nextly.seed.ts` — that path is
+ * now Payload-style: the project ships its own seed function under
+ * `src/endpoints/seed/index.ts` and an auth-gated POST route at
+ * `src/app/admin/api/seed/route.ts` invokes it. End users trigger
+ * the seed via the admin UI, not via boot-time magic. See
+ * tasks/nextly-dev-tasks/24-payload-alignment-and-fixes.md phase 3.
+ *
+ * @param adapter - Database adapter instance
+ * @param options - Optional configuration
+ * @returns Combined SeederResult
+ */
+declare function seedAll(adapter: DrizzleAdapter | AdapterWithDrizzle, options?: {
+    silent?: boolean;
+    /** Super admin email (default: admin@example.com) */
+    superAdminEmail?: string;
+    /** Super admin password (default: Admin@123456) */
+    superAdminPassword?: string;
+    /** Super admin name (default: Super Admin) */
+    superAdminName?: string;
+    /** Skip super admin seeding (default: false) */
+    skipSuperAdmin?: boolean;
+}): Promise<SeederResult>;
+
+export { seedAll, seedPermissions, seedSuperAdmin };
+export type { SeederResult };

package/dist/database/seeders/index.mjs

@@ -0,0 +1,47 @@
+import {
+  seedAll
+} from "../../chunk-B2GV2BWH.mjs";
+import {
+  seedPermissions
+} from "../../chunk-UOP63Q54.mjs";
+import {
+  seedSuperAdmin
+} from "../../chunk-PKMABBB5.mjs";
+import "../../chunk-NSEFNNU4.mjs";
+import "../../chunk-3FA7FKAV.mjs";
+import "../../chunk-AGJ6F2T3.mjs";
+import "../../chunk-KIMNCZGV.mjs";
+import "../../chunk-AK6Z23OX.mjs";
+import "../../chunk-INV7QKLG.mjs";
+import "../../chunk-GZ6DCQKC.mjs";
+import "../../chunk-SBACDPNX.mjs";
+import "../../chunk-RJLLGGPG.mjs";
+import "../../chunk-V4EQTOA4.mjs";
+import "../../chunk-I4JMR3UR.mjs";
+import "../../chunk-XZKLBMN6.mjs";
+import "../../chunk-IZWPRDC3.mjs";
+import "../../chunk-DNNG377Z.mjs";
+import "../../chunk-5HMZ644B.mjs";
+import "../../chunk-W5KKPZT5.mjs";
+import "../../chunk-56WO4WX7.mjs";
+import "../../chunk-2W3DVD7S.mjs";
+import "../../chunk-TS7GHTG2.mjs";
+import "../../chunk-H26B4FYG.mjs";
+import "../../chunk-DP3G27G5.mjs";
+import "../../chunk-DV6WVX2Q.mjs";
+import "../../chunk-UJ2IMJ4W.mjs";
+import "../../chunk-EGXBZCGC.mjs";
+import "../../chunk-G2AA4QLC.mjs";
+import "../../chunk-4MJLT6PZ.mjs";
+import "../../chunk-IUDOC7N7.mjs";
+import "../../chunk-LAZXX4HR.mjs";
+import "../../chunk-D5HQBNUB.mjs";
+import "../../chunk-NRUWQ5Z7.mjs";
+import "../../chunk-VTJADRO3.mjs";
+import "../../chunk-5APFUGAD.mjs";
+import "../../chunk-7P6ASYW6.mjs";
+export {
+  seedAll,
+  seedPermissions,
+  seedSuperAdmin
+};

package/dist/db-sync-demote-LJGKLB3S.mjs

@@ -0,0 +1,117 @@
+import {
+  serializeCollection
+} from "./chunk-6NFHQIJD.mjs";
+import {
+  createAdapter,
+  validateDatabaseEnv
+} from "./chunk-M52VMPGA.mjs";
+import {
+  loadConfig
+} from "./chunk-ZE6A3FYH.mjs";
+import "./chunk-GDBJ5JCU.mjs";
+import "./chunk-FQULBZ53.mjs";
+import {
+  CollectionRegistryService
+} from "./chunk-3FA7FKAV.mjs";
+import "./chunk-5HMZ644B.mjs";
+import "./chunk-2W3DVD7S.mjs";
+import "./chunk-TS7GHTG2.mjs";
+import "./chunk-H26B4FYG.mjs";
+import "./chunk-DP3G27G5.mjs";
+import "./chunk-DV6WVX2Q.mjs";
+import "./chunk-UJ2IMJ4W.mjs";
+import "./chunk-4MJLT6PZ.mjs";
+import "./chunk-LAZXX4HR.mjs";
+import "./chunk-D5HQBNUB.mjs";
+import "./chunk-NRUWQ5Z7.mjs";
+import "./chunk-7P6ASYW6.mjs";
+
+// src/cli/commands/db-sync-demote.ts
+import { createHash } from "crypto";
+import * as p from "@clack/prompts";
+async function loadNextlyConfig(cwd) {
+  return loadConfig({ cwd });
+}
+async function runDemote(slug, context) {
+  const { logger } = context;
+  let config;
+  try {
+    const result = await loadNextlyConfig(context.cwd);
+    config = result.config;
+  } catch (err) {
+    logger.error(
+      `Could not load nextly config: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  }
+  const collections = config.collections ?? [];
+  const collection = collections.find((c) => c.slug === slug);
+  if (!collection) {
+    logger.error(
+      `Collection '${slug}' not found in nextly.config.ts collections.`
+    );
+    process.exit(1);
+  }
+  const env = validateDatabaseEnv();
+  if (!env.valid) {
+    logger.error(env.errors.join("; "));
+    process.exit(1);
+  }
+  const adapter = await createAdapter({ logger });
+  const registry = new CollectionRegistryService(
+    adapter,
+    {
+      info: (msg) => logger.debug(msg),
+      warn: (msg) => logger.warn(msg),
+      error: (msg) => logger.error(msg),
+      debug: (msg) => logger.debug(msg)
+    }
+  );
+  const fields = collection.fields ?? [];
+  p.note(
+    serializeCollection({ slug, fields }),
+    `About to move '${slug}' to UI source`
+  );
+  const confirm2 = await p.confirm({
+    message: "Write to dynamic_collections so the Schema Builder can edit it?"
+  });
+  if (p.isCancel(confirm2) || !confirm2) {
+    logger.info("Demote cancelled.");
+    return;
+  }
+  const existing = await registry.getCollectionBySlug(slug);
+  if (existing) {
+    await registry.updateCollection(slug, {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      fields,
+      source: "ui"
+    });
+    logger.info(`Updated existing UI record for '${slug}'.`);
+  } else {
+    const tableName = collection.dbName ?? `dc_${slug}`;
+    const fieldsJson = JSON.stringify(fields);
+    const schemaHash = createHash("sha256").update(fieldsJson).digest("hex");
+    await registry.registerCollection({
+      slug,
+      labels: {
+        singular: collection.labels?.singular ?? collection.label ?? slug,
+        plural: collection.labels?.plural ?? slug
+      },
+      tableName,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      fields,
+      source: "ui",
+      schemaHash,
+      ...collection.description !== void 0 && {
+        description: collection.description
+      },
+      configPath: "demoted-from-code"
+    });
+  }
+  logger.info(
+    `Collection '${slug}' written to UI source. Remove its entry from your nextly.config.ts collections array, then restart dev server.`
+  );
+}
+export {
+  runDemote
+};

package/dist/db-sync-promote-B26VSYQF.mjs

@@ -0,0 +1,113 @@
+import {
+  serializeCollection
+} from "./chunk-6NFHQIJD.mjs";
+import {
+  createAdapter,
+  validateDatabaseEnv
+} from "./chunk-M52VMPGA.mjs";
+import {
+  CollectionRegistryService
+} from "./chunk-3FA7FKAV.mjs";
+import "./chunk-5HMZ644B.mjs";
+import "./chunk-2W3DVD7S.mjs";
+import "./chunk-TS7GHTG2.mjs";
+import "./chunk-H26B4FYG.mjs";
+import "./chunk-DP3G27G5.mjs";
+import "./chunk-DV6WVX2Q.mjs";
+import "./chunk-UJ2IMJ4W.mjs";
+import "./chunk-4MJLT6PZ.mjs";
+import "./chunk-LAZXX4HR.mjs";
+import "./chunk-D5HQBNUB.mjs";
+import "./chunk-NRUWQ5Z7.mjs";
+import "./chunk-7P6ASYW6.mjs";
+
+// src/cli/commands/db-sync-promote.ts
+import { appendFileSync, existsSync } from "fs";
+import * as p from "@clack/prompts";
+async function runPromote(slug, context) {
+  const { logger } = context;
+  const env = validateDatabaseEnv();
+  if (!env.valid) {
+    logger.error(env.errors.join("; "));
+    process.exit(1);
+  }
+  const adapter = await createAdapter({ logger });
+  const registry = new CollectionRegistryService(
+    adapter,
+    {
+      info: (msg) => logger.debug(msg),
+      warn: (msg) => logger.warn(msg),
+      error: (msg) => logger.error(msg),
+      debug: (msg) => logger.debug(msg)
+    }
+  );
+  const record = await registry.getCollectionBySlug(slug);
+  if (!record) {
+    logger.error(
+      `Collection '${slug}' not found in UI source (dynamic_collections).`
+    );
+    process.exit(1);
+  }
+  const fields = record.fields ?? [];
+  const code = serializeCollection({ slug, fields });
+  const action = await p.select({
+    message: `Preview generated code for '${slug}'. Action?`,
+    options: [
+      { value: "preview", label: "Show preview" },
+      { value: "accept", label: "Append to nextly.config.ts" },
+      { value: "decline", label: "Cancel" }
+    ]
+  });
+  if (p.isCancel(action) || action === "decline") {
+    logger.info("Promote cancelled.");
+    return;
+  }
+  if (action === "preview") {
+    p.note(code, "Generated code");
+    const confirm2 = await p.confirm({
+      message: "Append this to nextly.config.ts and delete the UI record?"
+    });
+    if (p.isCancel(confirm2) || !confirm2) {
+      logger.info("Promote cancelled.");
+      return;
+    }
+  }
+  const configPath = findConfigFile(context.cwd);
+  if (!configPath) {
+    logger.warn(
+      "Could not locate nextly.config.ts. The snippet is printed below; paste it into the collections array manually."
+    );
+    logger.info(code);
+  } else {
+    const snippet = [
+      "",
+      `// Promoted from UI source on ${(/* @__PURE__ */ new Date()).toISOString()}.`,
+      "// Move this entry into your collections array:",
+      ...code.split("\n").map((line) => `// ${line}`),
+      ""
+    ].join("\n");
+    appendFileSync(configPath, snippet);
+    logger.info(`Appended commented snippet to ${configPath}.`);
+  }
+  await registry.deleteCollection(slug);
+  logger.info(
+    `Collection '${slug}' removed from UI source. Move the snippet into your collections array, then restart dev server.`
+  );
+}
+function findConfigFile(cwd) {
+  const candidates = [
+    "nextly.config.ts",
+    "nextly.config.js",
+    "nextly.config.mjs",
+    "src/nextly.config.ts",
+    "src/nextly.config.js"
+  ];
+  for (const candidate of candidates) {
+    const full = `${cwd}/${candidate}`;
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+export {
+  runPromote
+};

package/dist/dev-reload-broadcaster-B73IQ53V.mjs

@@ -0,0 +1,25 @@
+import "./chunk-7P6ASYW6.mjs";
+
+// src/runtime/dev-reload-broadcaster.ts
+var g = globalThis;
+function ctls() {
+  if (!g.__nextly_sseCtrl) g.__nextly_sseCtrl = /* @__PURE__ */ new Set();
+  return g.__nextly_sseCtrl;
+}
+function subscribeDevReload(ctrl) {
+  ctls().add(ctrl);
+  return () => ctls().delete(ctrl);
+}
+function broadcastDevReload() {
+  for (const ctrl of ctls()) {
+    try {
+      ctrl.enqueue("event: schema-reload\ndata: {}\n\n");
+    } catch {
+      ctls().delete(ctrl);
+    }
+  }
+}
+export {
+  broadcastDevReload,
+  subscribeDevReload
+};

package/dist/dist-M2NOU37V.mjs

@@ -0,0 +1,19 @@
+import {
+  capture,
+  classifyError,
+  getStatus,
+  init,
+  resetConsent,
+  setEnabled,
+  shutdown
+} from "./chunk-6JNEPWRW.mjs";
+import "./chunk-7P6ASYW6.mjs";
+export {
+  capture,
+  classifyError,
+  getStatus,
+  init,
+  resetConsent,
+  setEnabled,
+  shutdown
+};

package/dist/drizzle-kit-lazy-D2M2PXR2.mjs

@@ -0,0 +1,13 @@
+import {
+  getDrizzleKitForDialect,
+  getMySQLDrizzleKit,
+  getPgDrizzleKit,
+  getSQLiteDrizzleKit
+} from "./chunk-3NZ2KMBL.mjs";
+import "./chunk-7P6ASYW6.mjs";
+export {
+  getDrizzleKitForDialect,
+  getMySQLDrizzleKit,
+  getPgDrizzleKit,
+  getSQLiteDrizzleKit
+};

package/dist/dynamic-collection-schema-service-IEXTPIZ7.mjs

@@ -0,0 +1,8 @@
+import {
+  DynamicCollectionSchemaService
+} from "./chunk-XZKLBMN6.mjs";
+import "./chunk-UJ2IMJ4W.mjs";
+import "./chunk-7P6ASYW6.mjs";
+export {
+  DynamicCollectionSchemaService
+};

package/dist/errors/index.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Canonical NextlyError codes and their HTTP status mappings.
+ *
+ * Plugin codes outside this enum must always pass an explicit `statusCode`
+ * to the NextlyError constructor (no enum lookup happens for unknown codes).
+ */
+declare const NEXTLY_ERROR_STATUS: {
+    readonly VALIDATION_ERROR: 400;
+    readonly INVALID_INPUT: 400;
+    readonly AUTH_REQUIRED: 401;
+    readonly AUTH_INVALID_CREDENTIALS: 401;
+    readonly TOKEN_EXPIRED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly CONFLICT: 409;
+    readonly DUPLICATE: 409;
+    readonly RATE_LIMITED: 429;
+    readonly PAYLOAD_TOO_LARGE: 413;
+    readonly UNSUPPORTED_MEDIA_TYPE: 415;
+    readonly INTERNAL_ERROR: 500;
+    readonly DATABASE_ERROR: 500;
+    readonly EXTERNAL_SERVICE_ERROR: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+};
+type NextlyErrorCode = keyof typeof NEXTLY_ERROR_STATUS;
+
+/**
+ * Structured public payloads attached to NextlyError instances.
+ *
+ * `publicData` lives in HTTP response bodies and Server Action results.
+ * It is safe by construction — never contains rejected values, identifiers
+ * the caller didn't already provide, or operator-only context.
+ */
+type ValidationPublicData = {
+    errors: Array<{
+        /** Dotted/bracketed path: "user.email", "items[2].quantity" */
+        path: string;
+        /** Stable machine code: "INVALID_FORMAT" | "REQUIRED" | "TOO_LOW" | ... */
+        code: string;
+        /** Complete sentence, ends with a period: "Must be a valid email address." */
+        message: string;
+    }>;
+};
+type RateLimitPublicData = {
+    retryAfterSeconds?: number;
+};
+type PublicData = ValidationPublicData | RateLimitPublicData | undefined;
+
+/**
+ * Code accepted by NextlyError: canonical codes get autocomplete, but plugin
+ * authors may use any UPPER_SNAKE string. The `(string & {})` trick preserves
+ * the literal union for IntelliSense without collapsing to plain `string`.
+ */
+type NextlyErrorCodeLike = NextlyErrorCode | (string & {});
+type NextlyErrorOpts = {
+    code: NextlyErrorCodeLike;
+    publicMessage: string;
+    publicData?: PublicData;
+    messageKey?: string;
+    logMessage?: string;
+    logContext?: Record<string, unknown>;
+    statusCode?: number;
+    cause?: Error;
+};
+type NextlyErrorResponseJSON = {
+    code: string;
+    message: string;
+    messageKey?: string;
+    data?: PublicData;
+    requestId: string;
+};
+/**
+ * Unified error class for Nextly. Used at every throw site across services,
+ * direct API, auth, and plugins. Carries two distinct payloads:
+ *
+ *   - Public  (`code`, `publicMessage`, `publicData`, `statusCode`, `messageKey`)
+ *     sent in HTTP responses and Server Action results.
+ *   - Log     (`logMessage`, `logContext`, `cause`, stack trace)
+ *     written to the server logger; never serialised to the wire.
+ *
+ * Use the static factories (notFound, forbidden, validation, ...) for the
+ * common cases. Use the free-form constructor for plugin codes or one-off
+ * shapes.
+ */
+declare class NextlyError extends Error {
+    readonly code: NextlyErrorCodeLike;
+    readonly statusCode: number;
+    readonly publicMessage: string;
+    readonly publicData?: PublicData;
+    readonly messageKey?: string;
+    readonly logMessage?: string;
+    readonly logContext?: Record<string, unknown>;
+    readonly cause?: Error;
+    readonly timestamp: Date;
+    constructor(opts: NextlyErrorOpts);
+    private static resolveStatusCode;
+    /** HTTP-safe JSON. Strips logMessage / logContext / cause / stack. */
+    toResponseJSON(requestId: string): NextlyErrorResponseJSON;
+    /** Operator-facing JSON for log lines. Includes everything. */
+    toLogJSON(requestId: string): Record<string, unknown>;
+    static invalidCredentials(opts?: {
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static authRequired(opts?: {
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static notFound(opts?: {
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static forbidden(opts?: {
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static validation(opts: {
+        errors: ValidationPublicData["errors"];
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static conflict(opts?: {
+        reason?: "version" | "state";
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static duplicate(opts?: {
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static rateLimited(opts?: {
+        retryAfterSeconds?: number;
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static internal(opts?: {
+        cause?: Error;
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    static serviceUnavailable(opts?: {
+        logMessage?: string;
+        cause?: Error;
+        logContext?: Record<string, unknown>;
+    }): NextlyError;
+    /**
+     * Convert a DbError (or arbitrary unknown thrown by the DB layer) to a
+     * NextlyError with a generic public message and rich logContext. Used by
+     * `withDbErrors` for auto-conversion (Pattern A) and by services that
+     * catch DB errors at boundaries (Pattern B). Spec §8.2 mapping table.
+     *
+     * Never leaks DB driver text, constraint names, or table names into
+     * `publicMessage`. All DB context goes into `logContext`. The original
+     * DbError is preserved as `cause`.
+     */
+    static fromDatabaseError(error: unknown): NextlyError;
+    static is(err: unknown): err is NextlyError;
+    static isCode(err: unknown, code: NextlyErrorCodeLike): err is NextlyError;
+    static isNotFound(err: unknown): err is NextlyError;
+    static isValidation(err: unknown): err is NextlyError;
+    static isAuthRequired(err: unknown): err is NextlyError;
+    static isForbidden(err: unknown): err is NextlyError;
+    static isConflict(err: unknown): err is NextlyError;
+    static isRateLimited(err: unknown): err is NextlyError;
+}
+
+export { NEXTLY_ERROR_STATUS, NextlyError };
+export type { NextlyErrorCode, NextlyErrorResponseJSON, PublicData, RateLimitPublicData, ValidationPublicData };

package/dist/errors/index.mjs

@@ -0,0 +1,10 @@
+import "../chunk-4MJLT6PZ.mjs";
+import {
+  NEXTLY_ERROR_STATUS,
+  NextlyError
+} from "../chunk-NRUWQ5Z7.mjs";
+import "../chunk-7P6ASYW6.mjs";
+export {
+  NEXTLY_ERROR_STATUS,
+  NextlyError
+};

package/dist/factory-IWMBKUJM.mjs

@@ -0,0 +1,15 @@
+import {
+  checkAdapterHealth,
+  createAdapter,
+  createAdapterFromEnv,
+  validateDatabaseEnv
+} from "./chunk-DP3G27G5.mjs";
+import "./chunk-DV6WVX2Q.mjs";
+import "./chunk-UJ2IMJ4W.mjs";
+import "./chunk-7P6ASYW6.mjs";
+export {
+  checkAdapterHealth,
+  createAdapter,
+  createAdapterFromEnv,
+  validateDatabaseEnv
+};