nextly 0.0.1 → 0.0.2-alpha.0

package/dist/chunk-WD34YQ6T.mjs

@@ -0,0 +1,381 @@
+import {
+  DEFAULT_SQL_KEYWORDS_SET,
+  RESERVED_SLUGS,
+  assertValidCollectionConfig,
+  assertValidComponentConfig,
+  validateComponentFieldRefShared,
+  validateFieldNameShared,
+  validateFieldTypeShared,
+  validateRelationshipTargetShared,
+  validateSelectOptionsShared,
+  validateSlugShared
+} from "./chunk-FQULBZ53.mjs";
+import {
+  simplePluralize
+} from "./chunk-VTJADRO3.mjs";
+
+// src/collections/config/define-collection.ts
+function toTitleCase(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function defineCollection(config) {
+  assertValidCollectionConfig(config);
+  const userFieldNames = new Set(
+    config.fields.filter(
+      (f) => "name" in f && typeof f.name === "string"
+    ).map((f) => f.name)
+  );
+  const systemFields = [];
+  if (!userFieldNames.has("title")) {
+    systemFields.push({
+      type: "text",
+      name: "title",
+      label: "Title",
+      required: true
+    });
+  }
+  if (!userFieldNames.has("slug")) {
+    systemFields.push({
+      type: "text",
+      name: "slug",
+      label: "Slug",
+      required: true,
+      unique: true
+    });
+  }
+  const fieldsWithSystem = [...systemFields, ...config.fields];
+  const singularLabel = config.labels?.singular ?? toTitleCase(config.slug);
+  const pluralLabel = config.labels?.plural ?? simplePluralize(singularLabel);
+  const normalized = {
+    ...config,
+    fields: fieldsWithSystem,
+    labels: {
+      singular: singularLabel,
+      plural: pluralLabel
+    },
+    timestamps: config.timestamps ?? true,
+    admin: {
+      ...config.admin,
+      pagination: {
+        defaultLimit: config.admin?.pagination?.defaultLimit ?? 10,
+        limits: config.admin?.pagination?.limits ?? [10, 25, 50, 100]
+      }
+    }
+  };
+  return normalized;
+}
+
+// src/singles/config/validate-single.ts
+var RESERVED_SINGLE_SLUGS = [...RESERVED_SLUGS];
+var RESERVED_SINGLE_SLUGS_SET = new Set(
+  RESERVED_SINGLE_SLUGS
+);
+function validateField(field, path, errors, seenNames) {
+  if (!field || typeof field !== "object") {
+    return;
+  }
+  const f = field;
+  const errsBase = errors;
+  if (!validateFieldTypeShared(f.type, path, errsBase)) {
+    return;
+  }
+  const fieldType = f.type;
+  validateFieldNameShared(
+    f.name,
+    path,
+    errsBase,
+    seenNames,
+    DEFAULT_SQL_KEYWORDS_SET
+  );
+  switch (fieldType) {
+    case "select":
+      validateSelectOptionsShared(f, path, errsBase, "select");
+      break;
+    case "radio":
+      validateSelectOptionsShared(f, path, errsBase, "radio");
+      break;
+    case "relationship":
+      validateRelationshipTargetShared(f, path, errsBase);
+      break;
+    case "repeater": {
+      const arrayFields = f.fields;
+      if (!arrayFields) {
+        errors.push({
+          path: `${path}.fields`,
+          message: "Array field must have a 'fields' array",
+          code: "ARRAY_FIELDS_REQUIRED"
+        });
+      } else if (Array.isArray(arrayFields)) {
+        validateFieldsArray(arrayFields, `${path}.fields`, errors);
+      }
+      break;
+    }
+    case "group": {
+      const groupFields = f.fields;
+      if (!groupFields) {
+        errors.push({
+          path: `${path}.fields`,
+          message: "Group field must have a 'fields' array",
+          code: "GROUP_FIELDS_REQUIRED"
+        });
+      } else if (Array.isArray(groupFields)) {
+        validateFieldsArray(groupFields, `${path}.fields`, errors);
+      }
+      break;
+    }
+    case "component":
+      validateComponentFieldRefShared(f, path, errsBase);
+      break;
+  }
+}
+function validateFieldsArray(fields, basePath, errors) {
+  const seenNames = /* @__PURE__ */ new Set();
+  fields.forEach((field, index) => {
+    const fieldPath = `${basePath}[${index}]`;
+    validateField(field, fieldPath, errors, seenNames);
+  });
+}
+function validateFields(fields, errors) {
+  const path = "fields";
+  if (!fields) {
+    errors.push({
+      path,
+      message: "Single fields are required",
+      code: "FIELDS_REQUIRED"
+    });
+    return;
+  }
+  if (!Array.isArray(fields)) {
+    errors.push({
+      path,
+      message: "Single fields must be an array",
+      code: "FIELDS_INVALID_TYPE"
+    });
+    return;
+  }
+  validateFieldsArray(fields, path, errors);
+}
+function validateAccess(access, errors) {
+  if (!access) {
+    return;
+  }
+  if (typeof access !== "object" || Array.isArray(access)) {
+    errors.push({
+      path: "access",
+      message: "Access control must be an object",
+      code: "ACCESS_INVALID_TYPE"
+    });
+    return;
+  }
+  const accessObj = access;
+  const validAccessKeys = ["read", "update"];
+  for (const key of validAccessKeys) {
+    const fn = accessObj[key];
+    if (fn !== void 0 && typeof fn !== "function") {
+      errors.push({
+        path: `access.${key}`,
+        message: `Access control '${key}' must be a function`,
+        code: "ACCESS_FUNCTION_INVALID"
+      });
+    }
+  }
+}
+function validateSingleConfig(config) {
+  const errors = [];
+  const errsBase = errors;
+  validateSlugShared(config.slug, errsBase, {
+    entityLabel: "Single",
+    reservedSlugsSet: RESERVED_SINGLE_SLUGS_SET,
+    sqlKeywordsSet: DEFAULT_SQL_KEYWORDS_SET
+  });
+  validateFields(config.fields, errors);
+  validateAccess(config.access, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertValidSingleConfig(config) {
+  const result = validateSingleConfig(config);
+  if (!result.valid) {
+    const errorMessages = result.errors.map((err) => `  - [${err.code}] ${err.path}: ${err.message}`).join("\n");
+    throw new Error(
+      `Invalid Single config for '${config.slug || "unknown"}':
+${errorMessages}`
+    );
+  }
+}
+
+// src/singles/config/define-single.ts
+function toTitleCase2(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function defineSingle(config) {
+  assertValidSingleConfig(config);
+  const userFieldNames = new Set(
+    config.fields.filter(
+      (f) => "name" in f && typeof f.name === "string"
+    ).map((f) => f.name)
+  );
+  const systemFields = [];
+  if (!userFieldNames.has("title")) {
+    systemFields.push({
+      type: "text",
+      name: "title",
+      label: "Title",
+      required: true
+    });
+  }
+  if (!userFieldNames.has("slug")) {
+    systemFields.push({
+      type: "text",
+      name: "slug",
+      label: "Slug",
+      required: true,
+      unique: true
+    });
+  }
+  const fieldsWithSystem = [...systemFields, ...config.fields];
+  const label = {
+    singular: config.label?.singular ?? toTitleCase2(config.slug)
+  };
+  const normalized = {
+    ...config,
+    fields: fieldsWithSystem,
+    label,
+    admin: {
+      ...config.admin
+    }
+  };
+  return normalized;
+}
+
+// src/components/config/define-component.ts
+function toTitleCase3(str) {
+  return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function defineComponent(config) {
+  assertValidComponentConfig(config);
+  const label = {
+    singular: config.label?.singular ?? toTitleCase3(config.slug)
+  };
+  const normalized = {
+    ...config,
+    label,
+    admin: {
+      ...config.admin
+    }
+  };
+  return normalized;
+}
+
+// src/collections/fields/helpers.ts
+var text = (config) => ({
+  ...config,
+  type: "text"
+});
+var textarea = (config) => ({
+  ...config,
+  type: "textarea"
+});
+var richText = (config) => ({
+  ...config,
+  type: "richText"
+});
+var email = (config) => ({
+  ...config,
+  type: "email"
+});
+var password = (config) => ({
+  ...config,
+  type: "password"
+});
+var code = (config) => ({
+  ...config,
+  type: "code"
+});
+var number = (config) => ({
+  ...config,
+  type: "number"
+});
+var checkbox = (config) => ({
+  ...config,
+  type: "checkbox"
+});
+var date = (config) => ({
+  ...config,
+  type: "date"
+});
+var select = (config) => ({
+  ...config,
+  type: "select"
+});
+var radio = (config) => ({
+  ...config,
+  type: "radio"
+});
+var upload = (config) => ({
+  ...config,
+  type: "upload"
+});
+var relationship = (config) => ({
+  ...config,
+  type: "relationship"
+});
+var array = (config) => ({
+  ...config,
+  type: "repeater"
+});
+var repeater = (config) => ({
+  ...config,
+  type: "repeater"
+});
+var group = (config) => ({
+  ...config,
+  type: "group"
+});
+var json = (config) => ({
+  ...config,
+  type: "json"
+});
+var component = (config) => ({
+  ...config,
+  type: "component"
+});
+var chips = (config) => ({
+  ...config,
+  type: "chips"
+});
+var option = (label, value) => ({
+  label,
+  value: value ?? label.toLowerCase().replace(/\s+/g, "_")
+});
+
+export {
+  defineCollection,
+  RESERVED_SINGLE_SLUGS,
+  validateSingleConfig,
+  assertValidSingleConfig,
+  defineSingle,
+  defineComponent,
+  text,
+  textarea,
+  richText,
+  email,
+  password,
+  code,
+  number,
+  checkbox,
+  date,
+  select,
+  radio,
+  upload,
+  relationship,
+  array,
+  repeater,
+  group,
+  json,
+  component,
+  chips,
+  option
+};

package/dist/chunk-WZBYMYVW.mjs

@@ -0,0 +1,14 @@
+import {
+  NextlyError
+} from "./chunk-NRUWQ5Z7.mjs";
+
+// src/api/auth-header-only.ts
+function requireAuthHeader(request) {
+  if (!request.headers.get("Authorization")) {
+    throw NextlyError.authRequired();
+  }
+}
+
+export {
+  requireAuthHeader
+};

package/dist/chunk-X23WKS3Z.mjs

@@ -0,0 +1,50 @@
+// src/auth/jwt/claims.ts
+var JWT_INTERNAL_CLAIMS = [
+  "iat",
+  "exp",
+  "jti",
+  "sub",
+  "nbf",
+  "aud",
+  "iss"
+];
+function buildClaims(input) {
+  const claims = {
+    sub: input.userId,
+    email: input.email,
+    name: input.name,
+    image: input.image,
+    roleIds: input.roleIds
+  };
+  if (input.customFields) {
+    for (const [key, value] of Object.entries(input.customFields)) {
+      if (!JWT_INTERNAL_CLAIMS.includes(
+        key
+      ) && !(key in claims)) {
+        claims[key] = value;
+      }
+    }
+  }
+  return claims;
+}
+
+// src/auth/jwt/sign.ts
+import { randomBytes } from "crypto";
+import { SignJWT } from "jose";
+var ALGORITHM = "HS256";
+function secretToKey(secret) {
+  return new TextEncoder().encode(secret);
+}
+async function signAccessToken(claims, secret, ttlSeconds = 900) {
+  const key = secretToKey(secret);
+  const jti = randomBytes(16).toString("hex");
+  const jwt = new SignJWT(claims).setProtectedHeader({ alg: ALGORITHM }).setIssuedAt().setExpirationTime(`${ttlSeconds}s`).setJti(jti);
+  return jwt.sign(key);
+}
+
+export {
+  JWT_INTERNAL_CLAIMS,
+  buildClaims,
+  secretToKey,
+  signAccessToken
+};