@gzl10/nexus-sdk 0.12.7 → 0.13.0

package/dist/chunk-6WVPKBUS.js

@@ -0,0 +1,364 @@
+// src/fields/id.ts
+var ID_TYPE_CONFIG = {
+  ulid: { size: 26, input: "text" },
+  uuid: { size: 36, input: "uuid" },
+  nanoid: { size: 21, input: "text" },
+  cuid2: { size: 24, input: "text" }
+};
+function calculatePatternSize(pattern, prefix, suffix) {
+  let size = 0;
+  const tokens = pattern.match(/\{[^}]+\}/g) || [];
+  for (const token of tokens) {
+    const tokenName = token.slice(1, -1);
+    if (tokenName === "prefix") {
+      size += prefix?.length ?? 0;
+    } else if (tokenName === "suffix") {
+      size += suffix?.length ?? 0;
+    } else if (tokenName === "year") {
+      size += 4;
+    } else if (tokenName === "year2") {
+      size += 2;
+    } else if (tokenName === "month" || tokenName === "day") {
+      size += 2;
+    } else if (tokenName.startsWith("seq:")) {
+      const paddingStr = tokenName.split(":")[1] ?? "6";
+      const padding = parseInt(paddingStr, 10) || 6;
+      size += padding;
+    } else if (tokenName === "seq") {
+      size += 10;
+    }
+  }
+  const literals = pattern.replace(/\{[^}]+\}/g, "");
+  size += literals.length;
+  return Math.max(size + 10, 50);
+}
+function useIdField(type = "ulid", config) {
+  const label = config?.label ?? "ID";
+  if (type === "auto") {
+    return {
+      label,
+      input: "number",
+      hidden: true,
+      db: { type: "integer", nullable: false, primary: true, autoIncrement: true, idType: "auto" }
+    };
+  }
+  if (type === "custom") {
+    return {
+      label,
+      input: "text",
+      hidden: true,
+      db: { type: "string", size: config?.size ?? 50, nullable: false, primary: true, idType: "custom" }
+    };
+  }
+  if (type === "pattern") {
+    const patternConfig = config?.pattern;
+    if (!patternConfig || !patternConfig.pattern) {
+      throw new Error("Pattern configuration is required for pattern ID type");
+    }
+    const size2 = calculatePatternSize(patternConfig.pattern, patternConfig.prefix, patternConfig.suffix);
+    return {
+      label,
+      input: "text",
+      hidden: true,
+      db: {
+        type: "string",
+        size: size2,
+        nullable: false,
+        primary: true,
+        idType: "pattern",
+        patternConfig
+      }
+    };
+  }
+  const { size, input } = ID_TYPE_CONFIG[type];
+  return {
+    label,
+    input,
+    hidden: true,
+    db: { type: "string", size, nullable: false, primary: true, idType: type }
+  };
+}
+
+// src/fields/text.ts
+function useTextField(config) {
+  const {
+    label,
+    hint,
+    required,
+    size = 255,
+    minLength,
+    nullable,
+    index,
+    unique,
+    defaultValue,
+    placeholder,
+    validation,
+    meta,
+    ...overrides
+  } = config;
+  const min = minLength ?? (required ? 1 : 0);
+  return {
+    label,
+    input: "text",
+    hint,
+    required: required ?? false,
+    defaultValue,
+    placeholder,
+    db: {
+      type: "string",
+      size,
+      nullable: nullable ?? !required,
+      default: defaultValue,
+      index: index ?? false,
+      unique: unique ?? false
+    },
+    validation: {
+      min,
+      max: size,
+      ...validation
+      // Custom validation overrides/extends
+    },
+    meta: {
+      searchable: true,
+      ...meta
+    },
+    ...overrides
+  };
+}
+function useTextUniqueField(config) {
+  return useTextField({
+    ...config,
+    required: true,
+    unique: true,
+    index: true
+  });
+}
+
+// src/fields/url.ts
+function useUrlField(config) {
+  const {
+    label,
+    hint,
+    required,
+    size = 500,
+    nullable,
+    index,
+    defaultValue,
+    placeholder,
+    meta,
+    ...overrides
+  } = config;
+  return {
+    label,
+    input: "url",
+    hint,
+    required: required ?? false,
+    defaultValue,
+    placeholder,
+    db: {
+      type: "string",
+      size,
+      nullable: nullable ?? !required,
+      default: defaultValue,
+      index: index ?? false
+    },
+    validation: {
+      max: size
+    },
+    meta: {
+      searchable: false,
+      ...meta
+    },
+    ...overrides
+  };
+}
+
+// src/fields/select.ts
+function createStaticSelect(config) {
+  const { label, options, defaultValue, hint, required, nullable, size, index, meta, ...overrides } = config;
+  const normalizedOptions = options.map(
+    (opt) => typeof opt === "string" ? { value: opt, label: opt } : opt
+  );
+  return {
+    label,
+    input: "select",
+    hint,
+    required: required ?? false,
+    defaultValue,
+    db: {
+      type: "string",
+      size: size ?? 50,
+      nullable: nullable ?? !required,
+      default: defaultValue,
+      index: index ?? false
+    },
+    options: {
+      static: normalizedOptions
+    },
+    meta: {
+      searchable: true,
+      ...meta
+    },
+    ...overrides
+  };
+}
+function createRelationSelect(config) {
+  const {
+    label,
+    table,
+    column = "id",
+    endpoint,
+    valueField = "id",
+    labelField = "name",
+    onDelete = "SET NULL",
+    hint,
+    required,
+    nullable,
+    size = 26,
+    index,
+    meta,
+    ...overrides
+  } = config;
+  return {
+    label,
+    input: "select",
+    hint,
+    required: required ?? false,
+    db: {
+      type: "string",
+      size,
+      nullable: nullable ?? !required,
+      index: index ?? true
+    },
+    relation: {
+      table,
+      column,
+      onDelete
+    },
+    options: {
+      endpoint,
+      valueField,
+      labelField
+    },
+    meta: {
+      searchable: true,
+      ...meta
+    },
+    ...overrides
+  };
+}
+function useSelectField(config) {
+  if ("table" in config) {
+    return createRelationSelect(config);
+  }
+  return createStaticSelect(config);
+}
+
+// src/fields/number.ts
+function useNumberField(config) {
+  const { label, hint, required, defaultValue, nullable, validation, meta, ...overrides } = config;
+  return {
+    label,
+    input: "number",
+    hint,
+    required: required ?? false,
+    defaultValue,
+    db: {
+      type: "integer",
+      nullable: nullable ?? !required,
+      ...defaultValue !== void 0 && { default: defaultValue }
+    },
+    validation,
+    meta: {
+      sortable: true,
+      ...meta
+    },
+    ...overrides
+  };
+}
+
+// src/fields/localized.ts
+function useLocalizedField(config) {
+  const { label, hint, required = true, meta, ...overrides } = config;
+  return {
+    label,
+    input: "text",
+    hint,
+    required,
+    db: {
+      type: "json",
+      nullable: !required
+    },
+    meta: {
+      searchable: true,
+      sortable: true,
+      ...meta
+    },
+    ...overrides
+  };
+}
+
+// src/fields/icon.ts
+function useIconField(config) {
+  const { label, hint, required, size = 100, placeholder, meta, ...overrides } = config;
+  return {
+    label,
+    input: "icon",
+    hint,
+    required: required ?? false,
+    placeholder,
+    db: {
+      type: "string",
+      size,
+      nullable: !required
+    },
+    meta: {
+      ...meta
+    },
+    ...overrides
+  };
+}
+
+// src/fields/common.ts
+var idField = useIdField("ulid");
+var userIdField = {
+  label: { en: "User", es: "Usuario" },
+  input: "select",
+  required: true,
+  db: { type: "string", size: 26, nullable: false, index: true },
+  relation: {
+    table: "users",
+    column: "id",
+    onDelete: "CASCADE"
+  },
+  meta: { showInForm: false }
+};
+var isActiveField = {
+  label: { en: "Active", es: "Activo" },
+  input: "switch",
+  defaultValue: true,
+  db: { type: "boolean", nullable: false, default: true },
+  meta: { sortable: true }
+};
+var orderField = {
+  label: { en: "Order", es: "Orden" },
+  input: "number",
+  defaultValue: 0,
+  db: { type: "integer", nullable: false, default: 0 },
+  meta: { sortable: true }
+};
+
+export {
+  useIdField,
+  useTextField,
+  useTextUniqueField,
+  useUrlField,
+  useSelectField,
+  useNumberField,
+  useLocalizedField,
+  useIconField,
+  idField,
+  userIdField,
+  isActiveField,
+  orderField
+};

package/dist/chunk-JIEVWBDA.js

@@ -0,0 +1,256 @@
+// src/types/localization.ts
+function resolveLocalized(value, locale) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  return value[locale] || value["en"] || Object.values(value)[0] || "";
+}
+function getCountLabel(label, labelPlural, count, locale) {
+  const resolved = count === 1 ? label : labelPlural || label;
+  return resolveLocalized(resolved, locale);
+}
+
+// src/types/field.ts
+function refOptions(module, entityOrLabel, labelField) {
+  const hasEntity = labelField !== void 0;
+  return {
+    endpoint: hasEntity ? `/${module}/${entityOrLabel}` : `/${module}`,
+    valueField: "id",
+    labelField: hasEntity ? labelField : entityOrLabel ?? "name"
+  };
+}
+function refMaster(master, options = {}) {
+  const table = `mst_${master}`;
+  return {
+    label: options.label ?? master,
+    input: options.input ?? "select",
+    required: options.required,
+    defaultValue: options.default,
+    db: { type: "string", size: 36 },
+    relation: { table, column: "id" },
+    options: {
+      endpoint: `/masters/${master}`,
+      valueField: "id",
+      labelField: "name"
+    }
+  };
+}
+
+// src/types/manifest.ts
+var CATEGORIES = {
+  data: { label: { en: "Data", es: "Datos" }, icon: "mdi:database", order: 1 },
+  content: { label: { en: "Content", es: "Contenido" }, icon: "mdi:file-document-outline", order: 2 },
+  assets: { label: { en: "Assets", es: "Recursos" }, icon: "mdi:folder-outline", order: 3 },
+  messaging: { label: { en: "Messaging", es: "Mensajer\xEDa" }, icon: "mdi:message-outline", order: 4 },
+  jobs: { label: { en: "Jobs", es: "Tareas" }, icon: "mdi:clock-outline", order: 5 },
+  ai: { label: { en: "AI", es: "IA" }, icon: "mdi:robot-outline", order: 6 },
+  analytics: { label: { en: "Analytics", es: "Anal\xEDticas" }, icon: "mdi:chart-line", order: 7 },
+  integrations: { label: { en: "Integrations", es: "Integraciones" }, icon: "mdi:puzzle-outline", order: 8 },
+  commerce: { label: { en: "Commerce", es: "Comercio" }, icon: "mdi:shopping-outline", order: 9 },
+  security: { label: { en: "Security", es: "Seguridad" }, icon: "mdi:shield-lock-outline", order: 10 },
+  legal: { label: { en: "Legal", es: "Legal" }, icon: "mdi:scale-balance", order: 11 },
+  settings: { label: { en: "Settings", es: "Configuraci\xF3n" }, icon: "mdi:cog-outline", order: 12 }
+};
+var CATEGORY_ORDER = Object.keys(CATEGORIES).sort((a, b) => CATEGORIES[a].order - CATEGORIES[b].order);
+
+// src/generators.ts
+function isPersistentEntity(entity) {
+  const withoutOwnTable = ["action", "external", "virtual", "computed", "single", "view"];
+  return !withoutOwnTable.includes(entity.type ?? "collection");
+}
+function isSingletonEntity(entity) {
+  return entity.type === "single";
+}
+function hasTable(entity) {
+  return "table" in entity && typeof entity.table === "string";
+}
+function getEntityName(entity) {
+  if ("table" in entity) {
+    const withoutPrefix = entity.table.replace(/^[a-z]{2,4}_/, "");
+    return toPascalCase(toSingular(withoutPrefix));
+  } else if ("key" in entity) {
+    return toPascalCase(entity.key);
+  } else {
+    const label = resolveLocalized(entity.label, "en");
+    return toSingular(label).replace(/\s+/g, "");
+  }
+}
+function getEntitySubject(entity) {
+  return entity.casl?.subject ?? tableToSubject(entity.table);
+}
+function toPascalCase(str) {
+  return str.split("_").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+function toSingular(str) {
+  if (str.endsWith("ies")) return str.slice(0, -3) + "y";
+  if (str.endsWith("s")) return str.slice(0, -1);
+  return str;
+}
+function tableToSubject(table) {
+  const match = table.match(/^([a-z]{2,4})_(.+)$/);
+  if (!match) {
+    const withoutPrefix = table.replace(/^[a-z]{2,4}_/, "");
+    return toPascalCase(toSingular(withoutPrefix));
+  }
+  const [, prefix, rest] = match;
+  const prefixPascal = prefix.charAt(0).toUpperCase() + prefix.slice(1);
+  return prefixPascal + toPascalCase(toSingular(rest));
+}
+
+// src/oidc/oidc-client.ts
+import { ofetch } from "ofetch";
+import * as jose from "jose";
+function createOidcClient() {
+  const jwksCache = /* @__PURE__ */ new Map();
+  async function discover(issuerUrl) {
+    const url = `${issuerUrl.replace(/\/$/, "")}/.well-known/openid-configuration`;
+    return ofetch(url);
+  }
+  function buildAuthorizationUrl(authorizationEndpoint, params) {
+    const url = new URL(authorizationEndpoint);
+    url.searchParams.set("client_id", params.clientId);
+    url.searchParams.set("redirect_uri", params.redirectUri);
+    url.searchParams.set("response_type", params.responseType || "code");
+    url.searchParams.set("scope", params.scopes.join(" "));
+    url.searchParams.set("state", params.state);
+    url.searchParams.set("nonce", params.nonce);
+    if (params.hostedDomain) {
+      url.searchParams.set("hd", params.hostedDomain);
+    }
+    return url.toString();
+  }
+  async function exchangeCode(params) {
+    const body = new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: params.clientId,
+      client_secret: params.clientSecret,
+      code: params.code,
+      redirect_uri: params.redirectUri
+    });
+    return ofetch(params.tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+  }
+  async function getUserInfo(accessToken, userInfoEndpoint) {
+    return ofetch(userInfoEndpoint, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+  }
+  function getJwksVerifier(jwksUri) {
+    let verifier = jwksCache.get(jwksUri);
+    if (!verifier) {
+      verifier = jose.createRemoteJWKSet(new URL(jwksUri));
+      jwksCache.set(jwksUri, verifier);
+    }
+    return verifier;
+  }
+  async function validateIdToken(idToken, config) {
+    const jwks = getJwksVerifier(config.jwksUri);
+    const { payload } = await jose.jwtVerify(idToken, jwks, {
+      issuer: config.issuer,
+      audience: config.clientId
+    });
+    if (config.nonce && payload["nonce"] !== config.nonce) {
+      throw new Error("Invalid nonce in ID token");
+    }
+    return payload;
+  }
+  return {
+    discover,
+    buildAuthorizationUrl,
+    exchangeCode,
+    getUserInfo,
+    validateIdToken
+  };
+}
+var _client = null;
+function getOidcClient() {
+  if (!_client) {
+    _client = createOidcClient();
+  }
+  return _client;
+}
+
+// src/oidc/state-manager.ts
+var DEFAULT_TTL_MS = 10 * 60 * 1e3;
+function createStateManager(ttlMs = DEFAULT_TTL_MS) {
+  const stateStore = /* @__PURE__ */ new Map();
+  function store(state, data) {
+    stateStore.set(state, data);
+  }
+  function verify(state) {
+    const stateData = stateStore.get(state);
+    if (!stateData) {
+      return null;
+    }
+    if (Date.now() - stateData.createdAt > ttlMs) {
+      stateStore.delete(state);
+      return null;
+    }
+    return stateData;
+  }
+  function clear(state) {
+    stateStore.delete(state);
+  }
+  function getTtl() {
+    return ttlMs;
+  }
+  return {
+    store,
+    verify,
+    clear,
+    getTtl
+  };
+}
+
+// src/oidc/domain-filter.ts
+function checkAllowedDomain(email, allowedDomainsJson) {
+  const emailDomain = email.split("@")[1]?.toLowerCase();
+  if (!emailDomain) {
+    return { allowed: false, domain: "" };
+  }
+  if (!allowedDomainsJson) {
+    return { allowed: true, domain: emailDomain };
+  }
+  try {
+    const allowedDomains = JSON.parse(allowedDomainsJson);
+    if (!Array.isArray(allowedDomains) || allowedDomains.length === 0) {
+      return { allowed: true, domain: emailDomain };
+    }
+    const normalizedDomains = allowedDomains.map((d) => d.toLowerCase());
+    const allowed = normalizedDomains.includes(emailDomain);
+    return { allowed, domain: emailDomain };
+  } catch {
+    return { allowed: true, domain: emailDomain };
+  }
+}
+function assertAllowedDomain(email, allowedDomainsJson, errorClass = Error) {
+  const result = checkAllowedDomain(email, allowedDomainsJson);
+  if (!result.allowed) {
+    throw new errorClass(`Email domain '${result.domain}' is not allowed`);
+  }
+}
+
+export {
+  resolveLocalized,
+  getCountLabel,
+  refOptions,
+  refMaster,
+  CATEGORIES,
+  CATEGORY_ORDER,
+  isPersistentEntity,
+  isSingletonEntity,
+  hasTable,
+  getEntityName,
+  getEntitySubject,
+  createOidcClient,
+  getOidcClient,
+  createStateManager,
+  checkAllowedDomain,
+  assertAllowedDomain
+};