enhance: add default value support for built-in property definition

deps/common/src/logseq/common/util.cljs

@@ -374,3 +374,13 @@ return: [{:id 3} {:id 2 :depend-on 3} {:id 1 :depend-on 2}]"
   [content]
   {:pre [(string? content)]}
   (string/replace-first content markdown-heading-pattern ""))
+
+(defn block-with-timestamps
+  "Adds updated-at timestamp and created-at if it doesn't exist"
+  [block]
+  (let [updated-at (time-ms)
+        block (cond->
+               (assoc block :block/updated-at updated-at)
+                (nil? (:block/created-at block))
+                (assoc :block/created-at updated-at))]
+    block))

deps/db/src/logseq/db/frontend/property.cljs

@@ -5,7 +5,32 @@
             [flatland.ordered.map :refer [ordered-map]]
             [logseq.common.uuid :as common-uuid]
             [logseq.db.frontend.db-ident :as db-ident]
-            [clojure.set :as set]))
+            [clojure.set :as set]
+            [logseq.db.frontend.order :as db-order]
+            [logseq.db.frontend.property.type :as db-property-type]
+            [logseq.common.util :as common-util]))
+
+(defn build-property-value-block
+  "Builds a property value entity given a block map/entity, a property entity or
+  ident and its property value"
+  [block property value]
+  (let [block-id (or (:db/id block) (:db/ident block))]
+    (-> (merge
+         {:block/uuid (d/squuid)
+          :block/format :markdown
+          :block/page (if (:block/page block)
+                        (:db/id (:block/page block))
+                        ;; page block
+                        block-id)
+          :block/parent block-id
+          :logseq.property/created-from-property (if (= (:db/ident property) :logseq.property/default-value)
+                                                   block-id
+                                                   (or (:db/id property) {:db/ident (:db/ident property)}))
+          :block/order (db-order/gen-key)}
+         (if (db-property-type/property-value-content? (get-in block [:block/schema :type]) property)
+           {:property.value/content value}
+           {:block/title value}))
+        common-util/block-with-timestamps)))
 
 ;; Main property vars
 ;; ==================
@@ -313,11 +338,18 @@
     :properties {:logseq.property/hide-empty-value true}
     :queryable? true}
    :logseq.task/recur-frequency
-   {:title "Recur frequency"
-    :schema {:type :number
-             :public? false}
-    :properties {:logseq.property/hide-empty-value true}
-    :queryable? true}
+   (let [schema {:type :number
+                 :public? false}]
+     {:title "Recur frequency"
+      :schema schema
+      :properties (let [block {:db/ident :logseq.task/recur-frequency
+                               :block/schema schema}
+                        property {:db/ident :logseq.property/default-value
+                                  :block/schema {:type :entity}}
+                        default-value (assoc (build-property-value-block block property 1) :db/id -1)]
+                    {:logseq.property/hide-empty-value true
+                     :logseq.property/default-value default-value})
+      :queryable? true})
    :logseq.task/recur-unit
    {:title "Recur unit"
     :schema {:type :number
@@ -332,7 +364,8 @@
                           [:logseq.task/recur-unit.week "Week"]
                           [:logseq.task/recur-unit.month "Month"]
                           [:logseq.task/recur-unit.year "Year"]])
-    :properties {:logseq.property/hide-empty-value true}
+    :properties {:logseq.property/hide-empty-value true
+                 :logseq.property/default-value :logseq.task/recur-unit.day}
     :queryable? true}
 
 ;; TODO: Add more props :Assignee, :Estimate, :Cycle, :Project

deps/db/src/logseq/db/frontend/property/build.cljs

@@ -2,8 +2,8 @@
   "Builds core property concepts"
   (:require [logseq.db.sqlite.util :as sqlite-util]
             [logseq.db.frontend.order :as db-order]
-            [datascript.core :as d]
-            [logseq.db.frontend.property.type :as db-property-type]))
+            [logseq.db.frontend.property.type :as db-property-type]
+            [logseq.db.frontend.property :as db-property]))
 
 (defn- closed-value-new-block
   [block-id block-type value property]
@@ -61,26 +61,7 @@
     (into [property-tx]
           (closed-values->blocks property))))
 
-(defn build-property-value-block
-  "Builds a property value entity given a block map/entity, a property entity or
-  ident and its property value"
-  [block property value]
-  (-> (merge
-       {:block/uuid (d/squuid)
-        :block/format :markdown
-        :block/page (if (:block/page block)
-                      (:db/id (:block/page block))
-                     ;; page block
-                      (:db/id block))
-        :block/parent (:db/id block)
-        :logseq.property/created-from-property (if (= (:db/ident property) :logseq.property/default-value)
-                                                 (:db/id block)
-                                                 (or (:db/id property) {:db/ident (:db/ident property)}))
-        :block/order (db-order/gen-key)}
-       (if (db-property-type/property-value-content? (get-in block [:block/schema :type]) property)
-         {:property.value/content value}
-         {:block/title value}))
-      sqlite-util/block-with-timestamps))
+(def build-property-value-block db-property/build-property-value-block)
 
 (defn build-property-values-tx-m
   "Builds a map of property names to their property value blocks to be

deps/db/src/logseq/db/frontend/schema.cljs

@@ -2,7 +2,7 @@
   "Main datascript schemas for the Logseq app"
   (:require [clojure.set :as set]))
 
-(def version 52)
+(def version 53)
 
 ;; A page is a special block, a page can corresponds to multiple files with the same ":block/name".
 (def ^:large-vars/data-var schema

deps/db/src/logseq/db/sqlite/common_db.cljs

@@ -197,9 +197,19 @@
                (d/datoms db :eavt (:db/id p)))))))
 
 (defn get-all-pages
+  "Get all pages including property page's default value"
   [db]
   (let [datoms (d/datoms db :avet :block/name)]
-    (mapcat (fn [d] (d/datoms db :eavt (:e d))) datoms)))
+    (mapcat (fn [d]
+              (let [datoms (d/datoms db :eavt (:e d))]
+                (mapcat
+                 (fn [d]
+                   (if (= (:a d) :logseq.property/default-value)
+                     (concat
+                      (d/datoms db :eavt (:v d))
+                      datoms)
+                     datoms))
+                 datoms))) datoms)))
 
 (defn get-page->refs-count
   [db]

deps/db/src/logseq/db/sqlite/create_graph.cljs

@@ -21,18 +21,25 @@
   (mapcat
    (fn [[db-ident {:keys [schema title closed-values properties] :as m}]]
      (let [prop-name (or title (name (:name m)))
-           blocks (if closed-values
-                    (db-property-build/build-closed-values
-                     db-ident
-                     prop-name
-                     {:db/ident db-ident :block/schema schema :closed-values closed-values}
-                     {:properties properties})
-                    [(sqlite-util/build-new-property
-                      db-ident
-                      schema
-                      {:title prop-name
-                       :properties properties})])]
-       blocks))
+           [property & others] (if closed-values
+                                 (db-property-build/build-closed-values
+                                  db-ident
+                                  prop-name
+                                  {:db/ident db-ident :block/schema schema :closed-values closed-values}
+                                  {:properties properties})
+                                 [(sqlite-util/build-new-property
+                                   db-ident
+                                   schema
+                                   {:title prop-name
+                                    :properties properties})])]
+       (->> (concat
+             [(dissoc property :logseq.property/default-value)]
+             others
+             (when-let [default-value (:logseq.property/default-value property)]
+               (when-let [uuid (:block/uuid property)]
+                 [{:block/uuid uuid
+                   :logseq.property/default-value default-value}])))
+            (remove nil?))))
    (dissoc built-in-properties :logseq.property/built-in?)))
 
 (defn- build-initial-properties

deps/db/src/logseq/db/sqlite/util.cljs

@@ -64,15 +64,7 @@
     db-schema/schema-for-db-based-graph
     db-schema/schema))
 
-(defn block-with-timestamps
-  "Adds updated-at timestamp and created-at if it doesn't exist"
-  [block]
-  (let [updated-at (common-util/time-ms)
-        block (cond->
-               (assoc block :block/updated-at updated-at)
-                (nil? (:block/created-at block))
-                (assoc :block/created-at updated-at))]
-    block))
+(def block-with-timestamps common-util/block-with-timestamps)
 
 (defn build-new-property
   "Build a standard new property so that it is is consistent across contexts. Takes

src/main/frontend/worker/db/migrate.cljs

@@ -16,7 +16,8 @@
             [logseq.common.uuid :as common-uuid]
             [clojure.string :as string]
             [logseq.db.frontend.content :as db-content]
-            [logseq.common.util.page-ref :as page-ref]))
+            [logseq.common.util.page-ref :as page-ref]
+            [logseq.outliner.property :as outliner-property]))
 
 ;; TODO: fixes/rollback
 ;; Frontend migrations
@@ -453,6 +454,16 @@
             eid (:db/id e)]
         [[:db/add eid :logseq.property.class/properties :logseq.task/scheduled]]))))
 
+(defn- add-repeat-default-values
+  [conn _search-db]
+  (let [db @conn]
+    (when (ldb/db-based-graph? db)
+      (let [e1 (d/entity db :logseq.task/recur-frequency)
+            e2 (d/entity db :logseq.task/recur-unit)]
+        (outliner-property/set-block-property! conn (:db/id e1) :logseq.property/default-value 1)
+        (outliner-property/set-block-property! conn (:db/id e2) :logseq.property/default-unit :logseq.task/recur-unit.day)
+        nil))))
+
 (def schema-version->updates
   "A vec of tuples defining datascript migrations. Each tuple consists of the
    schema version integer and a migration map. A migration map can have keys of :properties, :classes
@@ -534,7 +545,8 @@
    [50 {:classes [:logseq.class/Property :logseq.class/Tag :logseq.class/Page :logseq.class/Whiteboard]}]
    [51 {:fix replace-block-type-with-tags}]
    [52 {:properties [:logseq.task/scheduled :logseq.task/recur-frequency :logseq.task/recur-unit]
-        :fix add-scheduled-to-task}]])
+        :fix add-scheduled-to-task}]
+   [53 {:fix add-repeat-default-values}]])
 
 (let [max-schema-version (apply max (map first schema-version->updates))]
   (assert (<= db-schema/version max-schema-version))