alinea 0.4.0-preview.9 → 0.4.1

package/dist/alinea.d.ts

@@ -1,3 +1,4 @@
 export { createConfig, Meta as meta, page, root, schema, type, workspace } from 'alinea/core';
+export type { Infer as infer } from 'alinea/core';
 export { createMediaRoot as media } from 'alinea/core/media/MediaRoot';
 export * from './input.js';

package/dist/auth/passwordless/PasswordLessAuth.server.d.ts

@@ -1,4 +1,4 @@
-import { Handler } from 'alinea/backend/router/Router';
+import { Route } from 'alinea/backend/router/Router';
 import { Auth, Connection, User } from 'alinea/core';
 import type { Transporter } from 'nodemailer';
 export type PasswordLessAuthOptions = {
@@ -11,7 +11,7 @@ export type PasswordLessAuthOptions = {
 };
 export declare class PasswordLessAuth implements Auth.Server {
     protected options: PasswordLessAuthOptions;
-    handler: Handler<Request, Response | undefined>;
+    router: Route<Request, Response | undefined>;
     users: WeakMap<Request, User>;
     constructor(options: PasswordLessAuthOptions);
     contextFor(request: Request): Promise<Connection.AuthContext>;

package/dist/auth/passwordless/PasswordLessAuth.server.js

@@ -279,7 +279,7 @@ var PasswordLessAuth = class {
   constructor(options) {
     this.options = options;
     const matcher = router.startAt(Connection.routes.base);
-    this.handler = router(
+    this.router = router(
       matcher.post(Connection.routes.base + "/auth.passwordless").map(router.parseJson).map(async ({ body }) => {
         assert(body, LoginBody);
         const email = body.email;
@@ -305,7 +305,7 @@ var PasswordLessAuth = class {
       }).map(router.jsonResponse)
     ).recover(router.reportError);
   }
-  handler;
+  router;
   users = /* @__PURE__ */ new WeakMap();
   async contextFor(request) {
     return { user: await this.userFor(request) };

package/dist/backend/Database.d.ts

@@ -1,73 +1,50 @@
-import { Config, EntryUrlMeta, PageSeed, Syncable, Type } from 'alinea/core';
+import { Config, PageSeed, SyncResponse, Syncable } from 'alinea/core';
 import { EntryRecord } from 'alinea/core/EntryRecord';
 import { Mutation } from 'alinea/core/Mutation';
-import { Driver, Table } from 'rado';
-import { EntryPhase, EntryRow } from '../core/EntryRow.js';
+import { Driver, Select } from 'rado';
+import { EntryRow } from '../core/EntryRow.js';
 import { Source } from './Source.js';
 import { Store } from './Store.js';
 import { Target } from './Target.js';
-import { AlineaMeta } from './db/AlineaMeta.js';
-type Seed = {
+interface Seed {
     type: string;
     workspace: string;
     root: string;
     filePath: string;
     page: PageSeed;
-};
+}
 export declare class Database implements Syncable {
-    protected store: Store;
     config: Config;
+    store: Store;
     seed: Map<string, Seed>;
-    constructor(store: Store, config: Config);
-    updates(request: AlineaMeta): Promise<{
-        contentHash: string;
-        entries: {
-            entryId: string;
-            phase: EntryPhase;
-            title: string;
-            type: string;
-            seeded: boolean;
-            workspace: string;
-            root: string;
-            level: number;
-            filePath: string;
-            parentDir: string;
-            childrenDir: string | null;
-            index: string;
-            parent: string | null;
-            i18nId: string;
-            locale: string | null;
-            modifiedAt: number;
-            contentHash: string;
-            active: boolean;
-            main: boolean;
-            path: string;
-            url: string;
-            data: any;
-            searchableText: string;
-        }[];
-    }>;
-    versionIds(): Promise<Array<string>>;
-    syncWith(remote: Syncable): Promise<Array<string>>;
-    updateEntries(entries: Array<EntryRow>): Promise<void>;
-    applyMutations(mutations: Array<Mutation>): Promise<void>;
+    constructor(config: Config, store: Store);
+    syncRequired(contentHash: string): Promise<boolean>;
+    sync(contentHashes: Array<string>): Promise<SyncResponse>;
+    contentHashes(): Promise<string[]>;
+    syncWith(remote: Syncable, force?: boolean): Promise<Array<string>>;
+    applyMutations(mutations: Array<Mutation>, commitHash?: string): Promise<string[]>;
+    private applyPublish;
+    private updateChildren;
+    logEntries(): Promise<void>;
+    private applyMutation;
+    updateHash(tx: Driver.Async, selection: Select<EntryRow>): Promise<string[]>;
     meta(): Promise<{
+        commitHash: string;
         contentHash: string;
         modifiedAt: number;
     }>;
-    static index(query: Driver.Async): Promise<{
+    static index(tx: Driver.Async): Promise<{
         rowsAffected: number;
     }>;
     private writeMeta;
     inited: boolean;
-    private init;
-    entryUrl(type: Type, meta: EntryUrlMeta): string;
-    computeEntry(data: EntryRecord, meta: {
+    init(): Promise<void>;
+    computeEntry(record: EntryRecord, meta: {
         workspace: string;
         root: string;
         filePath: string;
-    }, seed?: Seed): Omit<Table.Insert<typeof EntryRow>, 'contentHash'>;
+    }, seed?: Seed): Omit<EntryRow, 'rowHash' | 'fileHash'>;
     seedData(): Map<string, Seed>;
-    fill(source: Source, target?: Target): Promise<void>;
+    fill(source: Source, commitHash: string, target?: Target): Promise<void>;
 }
 export {};