octocms 0.1.0

package/dist/localReader-I2THES24.js

@@ -0,0 +1,40 @@
+import "./chunk-7CFFE2I6.js";
+
+// lib/localReader.ts
+import fsPromises from "fs/promises";
+import path from "path";
+async function readLocalContentFile(filePath) {
+  const fullPath = path.join(process.cwd(), filePath);
+  try {
+    const data = await fsPromises.readFile(fullPath, { encoding: "utf8" });
+    return JSON.parse(data);
+  } catch (error) {
+    if ((error == null ? void 0 : error.code) === "ENOENT" || error instanceof SyntaxError) return null;
+    throw error;
+  }
+}
+async function readLocalRawFile(filePath) {
+  const fullPath = path.join(process.cwd(), filePath);
+  try {
+    return await fsPromises.readFile(fullPath, { encoding: "utf8" });
+  } catch (error) {
+    if ((error == null ? void 0 : error.code) === "ENOENT") return "";
+    throw error;
+  }
+}
+async function listLocalCollectionFiles(dirPath) {
+  const fullDir = path.join(process.cwd(), dirPath);
+  try {
+    const entries = await fsPromises.readdir(fullDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => `${dirPath}/${e.name}`);
+  } catch (error) {
+    if ((error == null ? void 0 : error.code) === "ENOENT") return [];
+    throw error;
+  }
+}
+export {
+  listLocalCollectionFiles,
+  readLocalContentFile,
+  readLocalRawFile
+};
+//# sourceMappingURL=localReader-I2THES24.js.map

package/dist/localReader-I2THES24.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/localReader.ts"],"sourcesContent":["import fsPromises from 'fs/promises';\nimport path from 'path';\n\n/** Read a JSON content file from local disk. Returns null on ENOENT or parse error. */\nexport async function readLocalContentFile(filePath: string): Promise<unknown | null> {\n  const fullPath = path.join(process.cwd(), filePath);\n  try {\n    const data = await fsPromises.readFile(fullPath, { encoding: 'utf8' });\n    return JSON.parse(data);\n  } catch (error: any) {\n    if (error?.code === 'ENOENT' || error instanceof SyntaxError) return null;\n    throw error;\n  }\n}\n\n/** Read a raw text file (e.g. companion .md) from local disk. Returns '' on ENOENT. */\nexport async function readLocalRawFile(filePath: string): Promise<string> {\n  const fullPath = path.join(process.cwd(), filePath);\n  try {\n    return await fsPromises.readFile(fullPath, { encoding: 'utf8' });\n  } catch (error: any) {\n    if (error?.code === 'ENOENT') return '';\n    throw error;\n  }\n}\n\n/** List .json files in a collection directory on local disk. Returns [] if directory does not exist. */\nexport async function listLocalCollectionFiles(dirPath: string): Promise<string[]> {\n  const fullDir = path.join(process.cwd(), dirPath);\n  try {\n    const entries = await fsPromises.readdir(fullDir, { withFileTypes: true });\n    return entries.filter((e) => e.isFile() && e.name.endsWith('.json')).map((e) => `${dirPath}/${e.name}`);\n  } catch (error: any) {\n    if (error?.code === 'ENOENT') return [];\n    throw error;\n  }\n}\n"],"mappings":";;;AAAA,OAAO,gBAAgB;AACvB,OAAO,UAAU;AAGjB,eAAsB,qBAAqB,UAA2C;AACpF,QAAM,WAAW,KAAK,KAAK,QAAQ,IAAI,GAAG,QAAQ;AAClD,MAAI;AACF,UAAM,OAAO,MAAM,WAAW,SAAS,UAAU,EAAE,UAAU,OAAO,CAAC;AACrE,WAAO,KAAK,MAAM,IAAI;AAAA,EACxB,SAAS,OAAY;AACnB,SAAI,+BAAO,UAAS,YAAY,iBAAiB,YAAa,QAAO;AACrE,UAAM;AAAA,EACR;AACF;AAGA,eAAsB,iBAAiB,UAAmC;AACxE,QAAM,WAAW,KAAK,KAAK,QAAQ,IAAI,GAAG,QAAQ;AAClD,MAAI;AACF,WAAO,MAAM,WAAW,SAAS,UAAU,EAAE,UAAU,OAAO,CAAC;AAAA,EACjE,SAAS,OAAY;AACnB,SAAI,+BAAO,UAAS,SAAU,QAAO;AACrC,UAAM;AAAA,EACR;AACF;AAGA,eAAsB,yBAAyB,SAAoC;AACjF,QAAM,UAAU,KAAK,KAAK,QAAQ,IAAI,GAAG,OAAO;AAChD,MAAI;AACF,UAAM,UAAU,MAAM,WAAW,QAAQ,SAAS,EAAE,eAAe,KAAK,CAAC;AACzE,WAAO,QAAQ,OAAO,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,KAAK,SAAS,OAAO,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,OAAO,IAAI,EAAE,IAAI,EAAE;AAAA,EACxG,SAAS,OAAY;AACnB,SAAI,+BAAO,UAAS,SAAU,QAAO,CAAC;AACtC,UAAM;AAAA,EACR;AACF;","names":[]}

package/dist/query.d.mts

@@ -0,0 +1,112 @@
+import { Config } from './types.mjs';
+import { InferConditions, CollectionNames } from './defineConfig.mjs';
+
+type SortDirection = 'asc' | 'desc';
+/**
+ * Chainable query builder for reading collection entries.
+ *
+ * Instantiate via `createQuery()`:
+ * ```ts
+ * // cms/__generated__/query.ts (auto-generated)
+ * import { createQuery } from 'octocms/query';
+ * import { config, type OctoConfig } from 'octocms/config';
+ * import type { EntryMap } from './types';
+ *
+ * export const query = createQuery<EntryMap, OctoConfig>(config);
+ * ```
+ *
+ * Then use:
+ * ```ts
+ * import { query } from 'cms/__generated__/query';
+ *
+ * const posts = await query('post')
+ *   .filter((p) => p.fields.title !== '')
+ *   .sort('publishedAt', 'desc')
+ *   .limit(10)
+ *   .toArray();
+ * ```
+ */
+declare class QueryBuilder<TEntryMap extends Record<string, any>, TOctoConfig extends Config, C extends keyof TEntryMap & string> {
+    private _collection;
+    private _octoConfig;
+    private _conditions;
+    private _filters;
+    private _sortField;
+    private _sortDir;
+    private _skip;
+    private _limit;
+    private _includeDrafts;
+    constructor(collection: C, octoConfig: TOctoConfig);
+    /**
+     * Set branch selections for conditional fields. Maps each conditional field name
+     * to the branch key to resolve. When called, only the selected branch value is returned
+     * for each conditional field; an error is thrown if a top-level conditional field key
+     * is missing.
+     *
+     * Without `.conditions()`, all branches are returned as a keyed object.
+     */
+    conditions(conds: InferConditions<TOctoConfig, C & CollectionNames<TOctoConfig>>): QueryBuilder<TEntryMap, TOctoConfig, C>;
+    /**
+     * Filter entries. Accepts either:
+     * - A **predicate function** for full control:
+     *   `.filter((e) => e.fields.publishedAt !== null)`
+     * - A **partial fields object** for simple equality matching:
+     *   `.filter({ title: 'Hello' })`
+     *
+     * Multiple `.filter()` calls are ANDed together.
+     */
+    filter(predicate: ((entry: TEntryMap[C]) => boolean) | Partial<TEntryMap[C]['fields']>): QueryBuilder<TEntryMap, TOctoConfig, C>;
+    /**
+     * Sort entries by a field name.
+     */
+    sort(field: Extract<keyof TEntryMap[C]['fields'], string>, direction?: SortDirection): QueryBuilder<TEntryMap, TOctoConfig, C>;
+    /** Skip the first `n` results (for pagination). */
+    skip(n: number): QueryBuilder<TEntryMap, TOctoConfig, C>;
+    /** Limit the result to at most `n` entries. */
+    limit(n: number): QueryBuilder<TEntryMap, TOctoConfig, C>;
+    /**
+     * Include draft and archived entries in results.
+     *
+     * By default, `query()` excludes entries with `sys.status` of `draft` or `archived`.
+     * Call `.includeDrafts()` to return all entries regardless of status.
+     */
+    includeDrafts(): QueryBuilder<TEntryMap, TOctoConfig, C>;
+    /** Execute the query and return all matching entries as an array. */
+    toArray(): Promise<TEntryMap[C][]>;
+    /**
+     * Execute the query and return the first matching entry, or `null`.
+     */
+    first(): Promise<TEntryMap[C] | null>;
+    /**
+     * Execute the query and return `{ items, total, hasMore }`.
+     */
+    paginate(): Promise<{
+        items: TEntryMap[C][];
+        total: number;
+        hasMore: boolean;
+    }>;
+}
+/**
+ * Create a type-safe content query function bound to your app's config and generated types.
+ *
+ * Call this once to create your app's `query` function, then import and use it everywhere:
+ *
+ * ```ts
+ * // cms/__generated__/query.ts (auto-generated by `npm run types:gen`)
+ * import { createQuery } from 'octocms/query';
+ * import { config, type OctoConfig } from 'octocms/config';
+ * import type { EntryMap } from './types';
+ *
+ * export const query = createQuery<EntryMap, OctoConfig>(config);
+ * ```
+ *
+ * Then in your pages/components:
+ * ```ts
+ * import { query } from 'cms/__generated__/query';
+ *
+ * const posts = await query('post').sort('publishedAt', 'desc').toArray();
+ * ```
+ */
+declare function createQuery<TEntryMap extends Record<string, any>, TOctoConfig extends Config>(octoConfig: TOctoConfig): <C extends keyof TEntryMap & string>(collection: C) => QueryBuilder<TEntryMap, TOctoConfig, C>;
+
+export { QueryBuilder, createQuery };

package/dist/query.js

@@ -0,0 +1,11 @@
+import {
+  QueryBuilder,
+  createQuery
+} from "./chunk-4VLN5EX2.js";
+import "./chunk-B47VXAHT.js";
+import "./chunk-7CFFE2I6.js";
+export {
+  QueryBuilder,
+  createQuery
+};
+//# sourceMappingURL=query.js.map

package/dist/query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/types.d.mts

@@ -0,0 +1,352 @@
+type EntryStatus = 'draft' | 'published' | 'changed' | 'archived' | 'merged';
+type FieldFormat = 'string' | 'text' | 'markdown' | 'boolean' | 'reference' | 'image' | 'number' | 'datetime' | 'json' | 'slug' | 'select' | 'url' | 'color' | 'conditional' | 'richtext';
+type ReferenceFieldConfig = {
+    /** Which collections this reference can point to. Defaults to all collections. */
+    collections?: string[];
+    /** 'one' = single reference, 'many' = array of references. Defaults to 'many'. */
+    cardinality?: 'one' | 'many';
+    /** Minimum number of references (for 'many'). */
+    min?: number;
+    /** Maximum number of references (for 'many'). */
+    max?: number;
+};
+/** Shared keys on every collection field definition. */
+type CollectionFieldBase = {
+    label: string;
+    entryTitle?: boolean;
+    /** When true, the field must be non-empty; save is blocked until valid. */
+    required?: boolean;
+    /** Optional helper text shown below the field in the admin UI. */
+    hint?: string;
+    /** Include in search index. Defaults to true for text-like formats (string, text, markdown, richtext, slug, select). Set false to exclude. */
+    searchable?: boolean;
+};
+type SelectOption = {
+    label: string;
+    value: string;
+};
+/** A branch in a conditional field — either inline fields or a reference to a collection. */
+type ConditionalBranchConfig = {
+    /** Unique key identifying this branch (used at query time to select it). */
+    key: string;
+    label: string;
+    /** Inline field definitions for this branch. */
+    fields: Record<string, CollectionField>;
+    collection?: never;
+} | {
+    /** Unique key identifying this branch (used at query time to select it). */
+    key: string;
+    label: string;
+    /** Reference branch — reuses an existing collection's schema. */
+    collection: string;
+    fields?: never;
+};
+type ConditionalFieldConfig = {
+    branches: readonly ConditionalBranchConfig[];
+};
+/** Prop definition for a custom component in a richtext field. */
+type RichTextComponentProp = {
+    name: string;
+    label: string;
+    type: 'string' | 'number' | 'boolean' | 'url' | 'image' | 'select';
+    options?: readonly SelectOption[];
+    required?: boolean;
+    defaultValue?: string | number | boolean;
+};
+/** A custom component that can be embedded in a richtext field. */
+type RichTextComponentDef = {
+    label: string;
+    /** Inline = sits within a paragraph. Block = occupies its own line. */
+    kind: 'inline' | 'block';
+    props: RichTextComponentProp[];
+};
+/** Controls which standard toolbar buttons appear in the richtext editor. All default to `true`. */
+type RichTextToolbarConfig = {
+    /** Bold / italic / underline toggles. */
+    formatting?: boolean;
+    /** Heading / paragraph block type selector. */
+    headings?: boolean;
+    /** Ordered / unordered list toggles. */
+    lists?: boolean;
+    /** Inline code toggle. */
+    code?: boolean;
+    /** Code block insertion. */
+    codeBlock?: boolean;
+    /** Link creation button. */
+    links?: boolean;
+    /** Table insertion button. */
+    tables?: boolean;
+    /** Horizontal rule insertion. */
+    thematicBreak?: boolean;
+    /** Standard markdown image insertion (URL-based). */
+    images?: boolean;
+    /** Undo / redo buttons. */
+    undoRedo?: boolean;
+};
+/** Configuration for the richtext field type's embeddable content. */
+type RichTextFieldConfig = {
+    embeds?: {
+        /** Allow embedding references to other entries. */
+        references?: {
+            collections?: string[];
+            /** Whether references can appear inline, as blocks, or both. Default: 'both'. */
+            display?: 'inline' | 'block' | 'both';
+        };
+        /** Allow embedding conditional (A/B) content branches. */
+        conditions?: boolean;
+        /** Allow embedding images from the media library. */
+        images?: boolean;
+        /** Allowed template variable names (e.g. ['user.firstName', 'site.name']). */
+        variables?: string[];
+        /** Custom components that can be embedded in the editor. */
+        components?: Record<string, RichTextComponentDef>;
+    };
+    /** Customize which standard toolbar buttons are shown. Omitted keys default to `true`. */
+    toolbar?: RichTextToolbarConfig;
+};
+/**
+ * Per-format field definitions (discriminated union on `format`).
+ * Use `as const` on `options` (and default arrays) in cms/octocms.config.ts for literal type inference in `InferFields`.
+ */
+type CollectionField = (CollectionFieldBase & {
+    format: 'string';
+    /**
+     * When `true`, the field stores a JSON array of strings (`string[]`) and the editor shows a tag-style list.
+     */
+    list?: true;
+}) | (CollectionFieldBase & {
+    format: 'text';
+    /** Textarea height; defaults to 4 in the editor. */
+    rows?: number;
+}) | (CollectionFieldBase & {
+    format: 'markdown';
+}) | (CollectionFieldBase & {
+    format: 'boolean';
+    /** When set, new entries get `"true"` or `"false"` in JSON. */
+    defaultBoolean?: boolean;
+    /** Radio labels in the editor (default Yes / No). */
+    booleanLabels?: {
+        true: string;
+        false: string;
+    };
+}) | (CollectionFieldBase & {
+    format: 'reference';
+    /** @deprecated Use `reference` config instead. Kept for backward compatibility. */
+    collection?: string;
+    reference?: ReferenceFieldConfig;
+}) | (CollectionFieldBase & {
+    format: 'image';
+}) | (CollectionFieldBase & {
+    format: 'number';
+    min?: number;
+    max?: number;
+    step?: number | 'any';
+    valueType?: 'int' | 'float';
+}) | (CollectionFieldBase & {
+    format: 'datetime';
+    dateOnly?: boolean;
+    defaultNow?: boolean;
+}) | (CollectionFieldBase & {
+    format: 'json';
+}) | (CollectionFieldBase & {
+    format: 'slug';
+    /**
+     * Field key to auto-generate from (must be a non-list `string` or `text` field).
+     * If omitted, the field marked `entryTitle: true` is used.
+     */
+    slugSource?: string;
+}) | (CollectionFieldBase & {
+    format: 'url';
+}) | (CollectionFieldBase & {
+    format: 'color';
+    /** When true, show a hex text field synced with the native color picker. */
+    allowInput?: boolean;
+}) | (CollectionFieldBase & {
+    format: 'select';
+    options: readonly SelectOption[];
+    multiple?: boolean;
+    /** Default for new entries when `multiple` is not true; must match an option `value`. */
+    defaultOption?: string;
+    /** Default for new entries when `multiple: true`; each entry must match an option `value`. */
+    defaultOptions?: readonly string[];
+}) | (CollectionFieldBase & {
+    format: 'conditional';
+    conditional: ConditionalFieldConfig;
+}) | (CollectionFieldBase & {
+    format: 'richtext';
+    richtext?: RichTextFieldConfig;
+});
+type Collection = {
+    label: string;
+    hasMany?: boolean;
+    fields: Record<string, CollectionField>;
+};
+/** Git / GitHub integration — branch names live in config (not environment variables). */
+type GitIntegrationConfig = {
+    /** Default branch; feature branches are created from here and PRs target this ref. */
+    baseBranch: string;
+    /**
+     * Branch that holds `cms/published.json` so Publish avoids committing to a protected base branch.
+     * When omitted, the pointer file is read and written on `baseBranch`.
+     */
+    publishedPointerBranch?: string;
+};
+type PublicCollectionSearchConfig = {
+    /** URL pattern with `:fieldName` placeholders resolved from entry fields.
+     *  Examples: '/blog/:slug', '/items/:id', '/' (fixed path for singletons) */
+    urlPattern: string;
+};
+type SearchConfig = {
+    /** Collections searchable on the public site + their URL mapping.
+     *  Omit or set to empty object = public search disabled. */
+    publicCollections?: Record<string, PublicCollectionSearchConfig>;
+};
+type Config = {
+    projectName: string;
+    contentFolder: string;
+    mediaFolder: string;
+    mediaAllowedFormats: string[];
+    git: GitIntegrationConfig;
+    collections: Record<string, Collection>;
+    /** Full-text search configuration. */
+    search?: SearchConfig;
+};
+/** Narrowed field types for parsers that only apply to one format. */
+type NumberCollectionField = Extract<CollectionField, {
+    format: 'number';
+}>;
+type DatetimeCollectionField = Extract<CollectionField, {
+    format: 'datetime';
+}>;
+type JsonCollectionField = Extract<CollectionField, {
+    format: 'json';
+}>;
+type SlugCollectionField = Extract<CollectionField, {
+    format: 'slug';
+}>;
+type SelectCollectionField = Extract<CollectionField, {
+    format: 'select';
+}>;
+type ConditionalCollectionField = Extract<CollectionField, {
+    format: 'conditional';
+}>;
+type RichTextCollectionField = Extract<CollectionField, {
+    format: 'richtext';
+}>;
+type SelectedFile = {
+    type: string;
+    id: string;
+    path: string;
+};
+type EntryListItem = {
+    type: string;
+    /** Filename stem (last path segment without `.json`), e.g. `post-123` for `post/post-123.json`. */
+    id: string;
+    /** Full repo-relative JSON path, e.g. `cms/content/post/post-123.json`. Use with `toReferenceKey(path)` for storage keys. */
+    path: string;
+    title: string;
+    status: EntryStatus;
+    /** ISO 8601 last-modified timestamp. Populated from fs.stat in dev mode; undefined in production. */
+    updatedAt?: string;
+};
+/** A reference item stored in a reference field value. */
+type ReferenceItem = {
+    /** The collection type (e.g. 'post', 'author'). */
+    type: string;
+    /** The entry ID (UUID or fixed ID). */
+    id: string;
+    /** Normalized reference key (e.g. 'post-abc.json'). */
+    path: string;
+    /** Display title extracted from the entry's entryTitle field. */
+    title: string;
+};
+type FileContextValues = {
+    selectedType: string | undefined;
+    selectedFile: SelectedFile | undefined;
+    onTypeClick: (type: string | undefined) => void;
+    onFileClick: (file: SelectedFile | undefined) => void;
+};
+/** Shape of `format: 'image'` fields after `query()` / `processEntry` resolution. */
+type ResolvedImageField = {
+    src: string;
+    alt: string;
+    width: number | null;
+    height: number | null;
+    blurDataURL: string | null;
+};
+type RichTextNode = {
+    type: 'paragraph';
+    children: RichTextNode[];
+} | {
+    type: 'blockquote';
+    children: RichTextNode[];
+} | {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: RichTextNode[];
+} | {
+    type: 'text';
+    value: string;
+    marks?: ('bold' | 'italic' | 'underline' | 'code')[];
+} | {
+    type: 'link';
+    url: string;
+    children: RichTextNode[];
+} | {
+    type: 'image';
+    image: ResolvedImageField;
+} | {
+    type: 'reference';
+    entry: unknown;
+    display: 'inline' | 'block';
+} | {
+    type: 'condition';
+    field: string;
+    branches: Record<string, RichTextDocument> | RichTextDocument;
+} | {
+    type: 'variable';
+    name: string;
+} | {
+    type: 'component';
+    name: string;
+    props: Record<string, unknown>;
+    children?: RichTextNode[];
+} | {
+    type: 'list';
+    ordered: boolean;
+    children: RichTextNode[];
+} | {
+    type: 'listItem';
+    children: RichTextNode[];
+} | {
+    type: 'thematicBreak';
+} | {
+    type: 'code';
+    lang?: string;
+    value: string;
+} | {
+    type: 'html';
+    value: string;
+} | {
+    type: 'break';
+};
+type RichTextDocument = {
+    type: 'doc';
+    content: RichTextNode[];
+};
+type MediaFile = {
+    id: string;
+    /** Required for new uploads; used as default alt text when the image is referenced. */
+    title: string;
+    originalName: string;
+    path: string;
+    folder: string;
+    publicUrl: string;
+    extension: string;
+    width: number | null;
+    height: number | null;
+    /** True when the entry stores a blur placeholder (data URL omitted from list payloads). */
+    hasBlurPlaceholder: boolean;
+};
+
+export type { Collection, CollectionField, ConditionalBranchConfig, ConditionalCollectionField, ConditionalFieldConfig, Config, DatetimeCollectionField, EntryListItem, EntryStatus, FieldFormat, FileContextValues, GitIntegrationConfig, JsonCollectionField, MediaFile, NumberCollectionField, PublicCollectionSearchConfig, ReferenceFieldConfig, ReferenceItem, ResolvedImageField, RichTextCollectionField, RichTextComponentDef, RichTextComponentProp, RichTextDocument, RichTextFieldConfig, RichTextNode, RichTextToolbarConfig, SearchConfig, SelectCollectionField, SelectOption, SelectedFile, SlugCollectionField };

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}