nextly 0.0.1 → 0.0.2-alpha.1

package/dist/chunk-3NZ2KMBL.mjs

@@ -0,0 +1,58 @@
+// src/database/drizzle-kit-lazy.ts
+import { createRequire } from "module";
+var g = globalThis;
+async function loadModule() {
+  if (g.__nextly_drizzleKitModule) return g.__nextly_drizzleKitModule;
+  const require2 = createRequire(import.meta.url);
+  const mod = require2("drizzle-kit/api");
+  g.__nextly_drizzleKitModule = mod;
+  return mod;
+}
+async function getPgDrizzleKit() {
+  if (g.__nextly_drizzleKitPg) return g.__nextly_drizzleKitPg;
+  const m = await loadModule();
+  g.__nextly_drizzleKitPg = {
+    pushSchema: m.pushSchema,
+    generateDrizzleJson: m.generateDrizzleJson,
+    generateMigration: m.generateMigration,
+    upSnapshot: m.upPgSnapshot
+  };
+  return g.__nextly_drizzleKitPg;
+}
+async function getMySQLDrizzleKit() {
+  if (g.__nextly_drizzleKitMySQL) return g.__nextly_drizzleKitMySQL;
+  const m = await loadModule();
+  g.__nextly_drizzleKitMySQL = {
+    pushSchema: m.pushMySQLSchema,
+    generateDrizzleJson: m.generateMySQLDrizzleJson,
+    generateMigration: m.generateMySQLMigration
+  };
+  return g.__nextly_drizzleKitMySQL;
+}
+async function getSQLiteDrizzleKit() {
+  if (g.__nextly_drizzleKitSQLite) return g.__nextly_drizzleKitSQLite;
+  const m = await loadModule();
+  g.__nextly_drizzleKitSQLite = {
+    pushSchema: m.pushSQLiteSchema,
+    generateDrizzleJson: m.generateSQLiteDrizzleJson,
+    generateMigration: m.generateSQLiteMigration
+  };
+  return g.__nextly_drizzleKitSQLite;
+}
+async function getDrizzleKitForDialect(dialect) {
+  switch (dialect) {
+    case "postgresql":
+      return getPgDrizzleKit();
+    case "mysql":
+      return getMySQLDrizzleKit();
+    case "sqlite":
+      return getSQLiteDrizzleKit();
+  }
+}
+
+export {
+  getPgDrizzleKit,
+  getMySQLDrizzleKit,
+  getSQLiteDrizzleKit,
+  getDrizzleKitForDialect
+};

package/dist/chunk-5APFUGAD.mjs

@@ -0,0 +1,89 @@
+// src/collections/fields/types/index.ts
+var DATA_FIELD_TYPES = [
+  "text",
+  "textarea",
+  "richText",
+  "email",
+  "password",
+  "code",
+  "number",
+  "checkbox",
+  "date",
+  "select",
+  "radio",
+  "upload",
+  "relationship",
+  "repeater",
+  "group",
+  "json",
+  "component",
+  "chips"
+];
+var VIRTUAL_FIELD_TYPES = [
+  "join"
+];
+var ALL_FIELD_TYPES = [
+  ...DATA_FIELD_TYPES,
+  ...VIRTUAL_FIELD_TYPES
+];
+
+// src/collections/fields/guards.ts
+function createTypeGuard(type) {
+  return (field) => field.type === type;
+}
+var isTextField = createTypeGuard("text");
+var isTextareaField = createTypeGuard("textarea");
+var isRichTextField = createTypeGuard("richText");
+var isEmailField = createTypeGuard("email");
+var isPasswordField = createTypeGuard("password");
+var isCodeField = createTypeGuard("code");
+var isNumberField = createTypeGuard("number");
+var isCheckboxField = (field) => field.type === "checkbox";
+var isDateField = createTypeGuard("date");
+var isSelectField = createTypeGuard("select");
+var isRadioField = createTypeGuard("radio");
+var isUploadField = createTypeGuard("upload");
+var isRelationshipField = createTypeGuard("relationship");
+function isRepeaterField(field) {
+  return field.type === "repeater";
+}
+var isGroupField = createTypeGuard("group");
+var isJSONField = createTypeGuard("json");
+var isComponentField = createTypeGuard("component");
+var isChipsField = createTypeGuard("chips");
+function isDataField(field) {
+  return DATA_FIELD_TYPES.includes(field.type);
+}
+function hasNestedFields(field) {
+  return ["repeater", "group"].includes(field.type);
+}
+function isRelationalField(field) {
+  return ["relationship", "upload"].includes(field.type);
+}
+
+export {
+  DATA_FIELD_TYPES,
+  VIRTUAL_FIELD_TYPES,
+  ALL_FIELD_TYPES,
+  isTextField,
+  isTextareaField,
+  isRichTextField,
+  isEmailField,
+  isPasswordField,
+  isCodeField,
+  isNumberField,
+  isCheckboxField,
+  isDateField,
+  isSelectField,
+  isRadioField,
+  isUploadField,
+  isRelationshipField,
+  isRepeaterField,
+  isGroupField,
+  isJSONField,
+  isComponentField,
+  isChipsField,
+  isDataField,
+  hasNestedFields,
+  isRelationalField
+};

package/dist/chunk-5HMZ644B.mjs

@@ -0,0 +1,108 @@
+// src/domains/schema/services/schema-hash.ts
+import { createHash } from "crypto";
+var SYSTEM_SCHEMA_VERSION = 2;
+var EXCLUDED_PROPERTIES = /* @__PURE__ */ new Set([
+  // Functions (can't be meaningfully hashed)
+  "validate",
+  "hooks",
+  "access",
+  "filterOptions",
+  "defaultValue",
+  // Can be a function
+  // Admin UI only (no database impact)
+  "admin",
+  "custom",
+  // React components
+  "components"
+]);
+var NESTED_FIELD_PROPERTIES = /* @__PURE__ */ new Set(["fields"]);
+function calculateSchemaHash(fields) {
+  const normalized = normalizeFields(fields);
+  const hashInput = {
+    systemVersion: SYSTEM_SCHEMA_VERSION,
+    fields: normalized
+  };
+  const json = JSON.stringify(hashInput);
+  return createHash("sha256").update(json).digest("hex");
+}
+function schemaHashesMatch(hash1, hash2) {
+  return hash1 === hash2;
+}
+function hasSchemaChanged(currentFields, previousHash) {
+  const currentHash = calculateSchemaHash(currentFields);
+  return !schemaHashesMatch(currentHash, previousHash);
+}
+function normalizeFields(fields) {
+  return fields.map((field) => normalizeField(field)).sort((a, b) => {
+    const aKey = a.name || a.type || "";
+    const bKey = b.name || b.type || "";
+    return aKey.localeCompare(bKey);
+  });
+}
+function normalizeField(field) {
+  const normalized = {};
+  const fieldRecord = field;
+  const sortedKeys = Object.keys(fieldRecord).sort();
+  for (const key of sortedKeys) {
+    const value = fieldRecord[key];
+    if (value === void 0) continue;
+    if (EXCLUDED_PROPERTIES.has(key)) continue;
+    if (typeof value === "function") continue;
+    if (NESTED_FIELD_PROPERTIES.has(key)) {
+      normalized[key] = normalizeNestedFields(key, value);
+    } else if (isPlainObject(value)) {
+      normalized[key] = normalizeObject(value);
+    } else if (Array.isArray(value)) {
+      normalized[key] = normalizeArray(value);
+    } else {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+function normalizeNestedFields(_key, value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return normalizeFields(value);
+}
+function normalizeObject(obj) {
+  const normalized = {};
+  const sortedKeys = Object.keys(obj).sort();
+  for (const key of sortedKeys) {
+    const value = obj[key];
+    if (value === void 0) continue;
+    if (typeof value === "function") continue;
+    if (isPlainObject(value)) {
+      normalized[key] = normalizeObject(value);
+    } else if (Array.isArray(value)) {
+      normalized[key] = normalizeArray(value);
+    } else {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+function normalizeArray(arr) {
+  return arr.map((item) => {
+    if (item === void 0 || item === null) return item;
+    if (typeof item === "function") return void 0;
+    if (isPlainObject(item)) {
+      return normalizeObject(item);
+    }
+    if (Array.isArray(item)) {
+      return normalizeArray(item);
+    }
+    return item;
+  }).filter((item) => item !== void 0);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+
+export {
+  SYSTEM_SCHEMA_VERSION,
+  calculateSchemaHash,
+  schemaHashesMatch,
+  hasSchemaChanged
+};

package/dist/chunk-67GXH6PR.mjs

@@ -0,0 +1,32 @@
+// src/api/request-id.ts
+var BASE32_ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+function base32(bytes) {
+  let out = "";
+  let buf = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    buf = buf << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      out += BASE32_ALPHABET[buf >> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) {
+    out += BASE32_ALPHABET[buf << 5 - bits & 31];
+  }
+  return out;
+}
+function generateRequestId() {
+  const bytes = new Uint8Array(10);
+  crypto.getRandomValues(bytes);
+  return "req_" + base32(bytes).slice(0, 16);
+}
+function readOrGenerateRequestId(req) {
+  return req.headers.get("x-request-id") ?? req.headers.get("x-vercel-id") ?? req.headers.get("cf-ray") ?? generateRequestId();
+}
+
+export {
+  generateRequestId,
+  readOrGenerateRequestId
+};